Implementation Guide: Monitor brand mentions and competitor activity across channels and send weekly digests

# After creating VPS in Hetzner Cloud Console, SSH in as root:
ssh root@YOUR_VPS_IP

# Create non-root user
adduser n8nadmin
usermod -aG sudo n8nadmin

# Copy SSH keys to new user
mkdir -p /home/n8nadmin/.ssh
cp ~/.ssh/authorized_keys /home/n8nadmin/.ssh/
chown -R n8nadmin:n8nadmin /home/n8nadmin/.ssh
chmod 700 /home/n8nadmin/.ssh
chmod 600 /home/n8nadmin/.ssh/authorized_keys

# Disable root login and password authentication
sed -i 's/PermitRootLogin yes/PermitRootLogin no/' /etc/ssh/sshd_config
sed -i 's/#PasswordAuthentication yes/PasswordAuthentication no/' /etc/ssh/sshd_config
systemctl restart sshd

# Configure UFW firewall
ufw default deny incoming
ufw default allow outgoing
ufw allow 22/tcp comment 'SSH'
ufw allow 80/tcp comment 'HTTP'
ufw allow 443/tcp comment 'HTTPS'
ufw enable

# Enable automatic security updates
apt update && apt install -y unattended-upgrades
dpkg-reconfigure -plow unattended-upgrades

# Attach 100 GB block storage volume (created in Hetzner console)
mkfs.ext4 /dev/sdb
mkdir -p /mnt/backup
mount /dev/sdb /mnt/backup
echo '/dev/sdb /mnt/backup ext4 defaults 0 2' >> /etc/fstab

# Log in as n8nadmin
ssh n8nadmin@YOUR_VPS_IP

# Install Docker Engine (official method)
sudo apt update
sudo apt install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo $VERSION_CODENAME) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Add n8nadmin to docker group (avoids needing sudo for docker commands)
sudo usermod -aG docker n8nadmin
newgrp docker

# Verify installation
docker --version
docker compose version

# Create project directory
mkdir -p ~/n8n-brand-monitor
cd ~/n8n-brand-monitor

# Create required subdirectories
mkdir -p caddy_data caddy_config n8n_data postgres_data backups

# Create .env file with secrets
cat > .env << 'ENVEOF'
# n8n Configuration
N8N_HOST=automation.yourmsp.com
N8N_PORT=5678
N8N_PROTOCOL=https
N8N_BASIC_AUTH_ACTIVE=true
N8N_BASIC_AUTH_USER=admin
N8N_BASIC_AUTH_PASSWORD=CHANGE_ME_TO_STRONG_PASSWORD
GENERIC_TIMEZONE=America/New_York
N8N_ENCRYPTION_KEY=GENERATE_A_RANDOM_32_CHAR_STRING
N8N_USER_MANAGEMENT_DISABLED=false

# PostgreSQL Configuration
POSTGRES_USER=n8n
POSTGRES_PASSWORD=CHANGE_ME_TO_STRONG_DB_PASSWORD
POSTGRES_DB=n8n
POSTGRES_NON_ROOT_USER=n8n
POSTGRES_NON_ROOT_PASSWORD=CHANGE_ME_TO_STRONG_DB_PASSWORD

# Domain for Caddy
DOMAIN_NAME=automation.yourmsp.com
ENVEOF

# Generate encryption key
openssl rand -hex 16
# Copy the output and paste it as N8N_ENCRYPTION_KEY in .env

# Create docker-compose.yml
cat > docker-compose.yml << 'DCEOF'
version: '3.8'

services:
  postgres:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      - POSTGRES_USER=${POSTGRES_USER}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
      - POSTGRES_DB=${POSTGRES_DB}
    volumes:
      - ./postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}']
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - n8n-net

  n8n:
    image: n8nio/n8n:latest
    restart: unless-stopped
    environment:
      - N8N_HOST=${N8N_HOST}
      - N8N_PORT=${N8N_PORT}
      - N8N_PROTOCOL=${N8N_PROTOCOL}
      - WEBHOOK_URL=https://${DOMAIN_NAME}/
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
      - GENERIC_TIMEZONE=${GENERIC_TIMEZONE}
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=${POSTGRES_DB}
      - DB_POSTGRESDB_USER=${POSTGRES_USER}
      - DB_POSTGRESDB_PASSWORD=${POSTGRES_PASSWORD}
      - N8N_METRICS=true
    volumes:
      - ./n8n_data:/home/node/.n8n
    depends_on:
      postgres:
        condition: service_healthy
    networks:
      - n8n-net

  caddy:
    image: caddy:2-alpine
    restart: unless-stopped
    ports:
      - '80:80'
      - '443:443'
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - ./caddy_data:/data
      - ./caddy_config:/config
    networks:
      - n8n-net

networks:
  n8n-net:
    driver: bridge
DCEOF

# Create Caddyfile
cat > Caddyfile << 'CADDYEOF'
{$DOMAIN_NAME} {
  reverse_proxy n8n:5678
  encode gzip
}
CADDYEOF

# First: In your DNS provider (e.g., Cloudflare, Route 53, GoDaddy):
# Create an A record: automation.yourmsp.com -> YOUR_VPS_IP
# TTL: 300 seconds (5 minutes) for fast propagation
# If using Cloudflare, set proxy status to 'DNS only' (gray cloud) initially

# Wait for DNS propagation (usually 1-5 minutes)
dig automation.yourmsp.com +short
# Should return your VPS IP

# Launch all services
cd ~/n8n-brand-monitor
docker compose up -d

# Check all containers are running
docker compose ps

# View logs for troubleshooting
docker compose logs -f
# (Ctrl+C to exit logs)

# Verify n8n is accessible
curl -I https://automation.yourmsp.com
# Should return HTTP 200

curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-YOUR_API_KEY_HERE" \
  -d '{"model": "gpt-5.4-mini", "messages": [{"role": "user", "content": "Say hello"}], "max_tokens": 50}'

# Test email delivery from VPS
curl --request POST \
  --url https://api.sendgrid.com/v3/mail/send \
  --header "Authorization: Bearer SG.YOUR_SENDGRID_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{"personalizations":[{"to":[{"email":"test@example.com"}]}],"from":{"email":"digest@acmecreative.com"},"subject":"Test Digest","content":[{"type":"text/plain","value":"SendGrid is working."}]}'

# Test Slack message from VPS
curl -X POST https://slack.com/api/chat.postMessage \
  -H "Authorization: Bearer xoxb-YOUR_BOT_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"channel": "#brand-alerts", "text": "🟢 Brand Monitor Bot is connected and working!"}'

# Create backup script
cat > ~/n8n-brand-monitor/backup.sh << 'BKEOF'
#!/bin/bash
set -e
BACKUP_DIR=/mnt/backup/n8n-$(date +%Y%m%d-%H%M%S)
mkdir -p $BACKUP_DIR

# Backup PostgreSQL database
docker compose -f ~/n8n-brand-monitor/docker-compose.yml exec -T postgres pg_dump -U n8n n8n > $BACKUP_DIR/n8n_db.sql

# Backup n8n data directory
cp -r ~/n8n-brand-monitor/n8n_data $BACKUP_DIR/n8n_data

# Backup configuration files
cp ~/n8n-brand-monitor/.env $BACKUP_DIR/
cp ~/n8n-brand-monitor/docker-compose.yml $BACKUP_DIR/
cp ~/n8n-brand-monitor/Caddyfile $BACKUP_DIR/

# Compress
tar -czf $BACKUP_DIR.tar.gz -C /mnt/backup $(basename $BACKUP_DIR)
rm -rf $BACKUP_DIR

# Retain only last 30 days of backups
find /mnt/backup -name 'n8n-*.tar.gz' -mtime +30 -delete

echo "Backup completed: $BACKUP_DIR.tar.gz"
BKEOF

chmod +x ~/n8n-brand-monitor/backup.sh

# Schedule daily backup at 2:00 AM
(crontab -l 2>/dev/null; echo '0 2 * * * /home/n8nadmin/n8n-brand-monitor/backup.sh >> /var/log/n8n-backup.log 2>&1') | crontab -

# Test backup script
~/n8n-brand-monitor/backup.sh

Node Configuration:

1. CRON TRIGGER NODE
   - Type: Schedule Trigger
   - Rule: Every 6 hours (0 */6 * * *)
   - Timezone: Client's timezone (e.g., America/New_York)

2. HTTP REQUEST NODE - 'Fetch Brand24 Mentions'
   - Method: GET
   - URL: https://api.brand24.com/v3/search
   - Authentication: Header Auth (Brand24 API credential)
   - Query Parameters:
     - projectId: {{$env.BRAND24_PROJECT_ID}}
     - sinceDate: {{$now.minus(6, 'hours').toISO()}}
     - limit: 100
     - sort: date_desc
   - Response Format: JSON

3. IF NODE - 'Check for Results'
   - Condition: {{$json.data.length}} > 0
   - True: Continue to processing
   - False: End (no new mentions)

4. SPLIT IN BATCHES NODE - 'Process Each Mention'
   - Batch Size: 1

5. FUNCTION NODE - 'Classify Urgency'
   - Code:
      const mention = $input.item.json;
   const content = (mention.description || '').toLowerCase();
   const reach = mention.reach || 0;
   const sentiment = mention.sentiment || 0;
   
   // Crisis keywords
   const crisisKeywords = ['lawsuit', 'scandal', 'recall', 'hack', 'breach', 'fraud', 'fired', 'boycott', 'investigation'];
   const hasCrisisKeyword = crisisKeywords.some(kw => content.includes(kw));
   
   // Classify urgency
   let urgency = 'standard';
   let sentimentLabel = 'Neutral';
   
   if (sentiment < 0) sentimentLabel = 'Negative';
   else if (sentiment > 0) sentimentLabel = 'Positive';
   
   if (hasCrisisKeyword || (sentimentLabel === 'Negative' && reach > 10000)) {
     urgency = 'critical';
   } else if (sentimentLabel === 'Negative' && reach > 1000) {
     urgency = 'high';
   } else if (reach > 5000) {
     urgency = 'high';
   }
   
   return {
     json: {
       mention_id: mention.id,
       date: mention.date,
       source: mention.source_type,
       platform: mention.domain || mention.source_type,
       author: mention.author || 'Unknown',
       content: mention.description || '',
       sentiment: sentimentLabel,
       sentiment_score: sentiment,
       reach: reach,
       url: mention.url || '',
       brand_or_competitor: mention.query || 'Unknown',
       processed: false,
       urgency: urgency
     }
   };
   
6. GOOGLE SHEETS NODE - 'Log to Archive'
   - Operation: Append Row
   - Document ID: {{SPREADSHEET_ID}}
   - Sheet Name: Raw Mentions
   - Columns: Map all fields from Function node

7. SWITCH NODE - 'Route by Urgency'
   - Rules:
     - urgency equals 'critical' → Critical Alert path
     - urgency equals 'high' → High Alert path
     - Default → End (standard mentions logged only)

8. SLACK NODE - 'Critical Alert' (Critical path)
   - Channel: #brand-alerts
   - Message:
      🚨 *CRITICAL BRAND ALERT*
   
   *Source:* {{$json.platform}}
   *Sentiment:* {{$json.sentiment}} (Score: {{$json.sentiment_score}})
   *Reach:* {{$json.reach.toLocaleString()}} people
   *Author:* {{$json.author}}
   
   > {{$json.content.substring(0, 500)}}
   
   🔗 <{{$json.url}}|View Original>
   📊 Brand/Keyword: {{$json.brand_or_competitor}}
   
9. SLACK NODE - 'High Priority Alert' (High path)
   - Channel: #brand-alerts
   - Message:
      ⚠️ *High Priority Mention*
   
   *Source:* {{$json.platform}} | *Sentiment:* {{$json.sentiment}} | *Reach:* {{$json.reach.toLocaleString()}}
   *Author:* {{$json.author}}
   
   > {{$json.content.substring(0, 300)}}
   
   🔗 <{{$json.url}}|View Original>
   
10. ERROR TRIGGER NODE - 'On Error'
    - Connects to Slack node sending to MSP's #ops-alerts channel
    - Message: '🔴 Brand Monitor workflow error for [Client Name]: {{$json.error.message}}'

# Workflow Name: Brand Monitor - Weekly Digest

Node Configuration:

1. CRON TRIGGER NODE
   - Type: Schedule Trigger
   - Rule: Every Monday at 7:00 AM (0 7 * * 1)
   - Timezone: Client's timezone

2. GOOGLE SHEETS NODE - 'Fetch This Week Mentions'
   - Operation: Read Rows
   - Document ID: {{SPREADSHEET_ID}}
   - Sheet Name: Raw Mentions
   - Filters: date >= {{$now.minus(7, 'days').toISODate()}}

3. FUNCTION NODE - 'Aggregate Statistics'
   - Code:
      const mentions = $input.all().map(i => i.json);
   
   const totalMentions = mentions.length;
   const positiveMentions = mentions.filter(m => m.sentiment === 'Positive').length;
   const negativeMentions = mentions.filter(m => m.sentiment === 'Negative').length;
   const neutralMentions = mentions.filter(m => m.sentiment === 'Neutral').length;
   
   const totalReach = mentions.reduce((sum, m) => sum + (parseInt(m.reach) || 0), 0);
   
   // Group by brand/competitor
   const byBrand = {};
   mentions.forEach(m => {
     const key = m.brand_or_competitor || 'Unknown';
     if (!byBrand[key]) byBrand[key] = { count: 0, positive: 0, negative: 0, neutral: 0, reach: 0 };
     byBrand[key].count++;
     byBrand[key].reach += parseInt(m.reach) || 0;
     if (m.sentiment === 'Positive') byBrand[key].positive++;
     else if (m.sentiment === 'Negative') byBrand[key].negative++;
     else byBrand[key].neutral++;
   });
   
   // Group by platform
   const byPlatform = {};
   mentions.forEach(m => {
     const key = m.platform || 'Unknown';
     if (!byPlatform[key]) byPlatform[key] = 0;
     byPlatform[key]++;
   });
   
   // Top mentions by reach
   const topPositive = mentions
     .filter(m => m.sentiment === 'Positive')
     .sort((a, b) => (parseInt(b.reach) || 0) - (parseInt(a.reach) || 0))
     .slice(0, 5);
   
   const topNegative = mentions
     .filter(m => m.sentiment === 'Negative')
     .sort((a, b) => (parseInt(b.reach) || 0) - (parseInt(a.reach) || 0))
     .slice(0, 5);
   
   // Calculate share of voice
   const totalBrandMentions = Object.values(byBrand).reduce((sum, b) => sum + b.count, 0);
   const shareOfVoice = {};
   for (const [brand, data] of Object.entries(byBrand)) {
     shareOfVoice[brand] = ((data.count / totalBrandMentions) * 100).toFixed(1) + '%';
   }
   
   // Prepare mention summaries for GPT (limit to 50 most impactful)
   const topMentionsForGPT = mentions
     .sort((a, b) => (parseInt(b.reach) || 0) - (parseInt(a.reach) || 0))
     .slice(0, 50)
     .map(m => `[${m.sentiment}] [${m.platform}] [Reach: ${m.reach}] ${m.author}: ${m.content.substring(0, 200)}`)
     .join('\n');
   
   return {
     json: {
       stats: {
         totalMentions, positiveMentions, negativeMentions, neutralMentions, totalReach,
         sentimentRatio: totalMentions > 0 ? ((positiveMentions / totalMentions) * 100).toFixed(1) : '0',
         byBrand, byPlatform, shareOfVoice
       },
       topPositive: topPositive.map(m => ({ author: m.author, content: m.content.substring(0, 200), reach: m.reach, url: m.url, platform: m.platform })),
       topNegative: topNegative.map(m => ({ author: m.author, content: m.content.substring(0, 200), reach: m.reach, url: m.url, platform: m.platform })),
       mentionsForGPT: topMentionsForGPT,
       weekStart: $now.minus(7, 'days').toISODate(),
       weekEnd: $now.toISODate()
     }
   };

- From: digest@clientdomain.com (configured sender)
- To: {{DIGEST_RECIPIENTS}} (comma-separated list)
- Subject: '📊 Weekly Brand Intelligence Digest | {{$json.weekStart}} – {{$json.weekEnd}}'
- Content Type: text/html
- Body: {{$json.emailHtml}}

# 'Post Digest Summary to Slack' message template (Channel: #weekly-digest)

📊 *Weekly Brand Intelligence Digest*
📅 {{$json.weekStart}} – {{$json.weekEnd}}

*Key Numbers:*
• Total Mentions: {{$json.stats.totalMentions}}
• Sentiment: {{$json.stats.sentimentRatio}}% positive
• Total Reach: {{$json.stats.totalReach.toLocaleString()}}

*AI Summary:*
{{$json.aiAnalysis.substring(0, 1500)}}

📧 Full digest sent to the team via email.

- Operation: Append Row
- Sheet: Weekly Digests
- Data: week_start, week_end, total_mentions, avg_sentiment, top_positive, top_negative, competitor_summary, digest_html, sent_at

const stats = $input.item.json.stats;
const aiAnalysis = $input.item.json.aiAnalysis || $('Generate AI Analysis').item.json.message.content;
const weekStart = $input.item.json.weekStart;
const weekEnd = $input.item.json.weekEnd;
const topPositive = $input.item.json.topPositive || [];
const topNegative = $input.item.json.topNegative || [];

// Convert markdown headers to HTML
const analysisHtml = aiAnalysis
  .replace(/## (\d+\..+)/g, '<h3 style="color:#1a1a2e;margin-top:24px;margin-bottom:8px;font-size:16px;">$1</h3>')
  .replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>')
  .replace(/\n- /g, '\n<br>• ')
  .replace(/\n\* /g, '\n<br>• ')
  .replace(/\n/g, '<br>');

// CLIENT BRANDING - UPDATE THESE VALUES PER CLIENT
const CLIENT_NAME = 'Agency Name';  // CHANGE THIS
const LOGO_URL = 'https://via.placeholder.com/200x50?text=Logo';  // CHANGE THIS
const PRIMARY_COLOR = '#1a1a2e';  // CHANGE THIS
const ACCENT_COLOR = '#e94560';  // CHANGE THIS

const sentimentColor = parseFloat(stats.sentimentRatio) >= 60 ? '#27ae60' : parseFloat(stats.sentimentRatio) >= 40 ? '#f39c12' : '#e74c3c';

const emailHtml = `
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Weekly Brand Intelligence Digest</title>
</head>
<body style="margin:0;padding:0;background-color:#f4f4f8;font-family:Arial,Helvetica,sans-serif;">
  <table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="background-color:#f4f4f8;">
    <tr><td align="center" style="padding:20px 10px;">
      <table role="presentation" width="600" cellpadding="0" cellspacing="0" style="background-color:#ffffff;border-radius:8px;overflow:hidden;box-shadow:0 2px 8px rgba(0,0,0,0.1);">
        
        <!-- Header -->
        <tr><td style="background-color:${PRIMARY_COLOR};padding:24px 32px;text-align:center;">
          <img src="${LOGO_URL}" alt="${CLIENT_NAME}" style="max-width:180px;height:auto;margin-bottom:12px;">
          <h1 style="color:#ffffff;margin:0;font-size:22px;font-weight:600;">Weekly Brand Intelligence Digest</h1>
          <p style="color:#ccccdd;margin:8px 0 0;font-size:14px;">${weekStart} — ${weekEnd}</p>
        </td></tr>
        
        <!-- Stats Bar -->
        <tr><td style="padding:24px 32px;background-color:#f8f9fa;">
          <table role="presentation" width="100%" cellpadding="0" cellspacing="0">
            <tr>
              <td width="25%" style="text-align:center;padding:8px;">
                <div style="font-size:28px;font-weight:700;color:${PRIMARY_COLOR};">${stats.totalMentions}</div>
                <div style="font-size:12px;color:#666;text-transform:uppercase;letter-spacing:0.5px;">Total Mentions</div>
              </td>
              <td width="25%" style="text-align:center;padding:8px;">
                <div style="font-size:28px;font-weight:700;color:${sentimentColor};">${stats.sentimentRatio}%</div>
                <div style="font-size:12px;color:#666;text-transform:uppercase;letter-spacing:0.5px;">Positive</div>
              </td>
              <td width="25%" style="text-align:center;padding:8px;">
                <div style="font-size:28px;font-weight:700;color:${ACCENT_COLOR};">${stats.negativeMentions}</div>
                <div style="font-size:12px;color:#666;text-transform:uppercase;letter-spacing:0.5px;">Negative</div>
              </td>
              <td width="25%" style="text-align:center;padding:8px;">
                <div style="font-size:28px;font-weight:700;color:${PRIMARY_COLOR};">${stats.totalReach.toLocaleString()}</div>
                <div style="font-size:12px;color:#666;text-transform:uppercase;letter-spacing:0.5px;">Total Reach</div>
              </td>
            </tr>
          </table>
        </td></tr>
        
        <!-- AI Analysis -->
        <tr><td style="padding:24px 32px;">
          ${analysisHtml}
        </td></tr>
        
        <!-- Share of Voice -->
        <tr><td style="padding:0 32px 24px;">
          <h3 style="color:${PRIMARY_COLOR};border-bottom:2px solid ${ACCENT_COLOR};padding-bottom:8px;">Share of Voice</h3>
          <table role="presentation" width="100%" cellpadding="8" cellspacing="0" style="font-size:14px;">
            ${Object.entries(stats.shareOfVoice || {}).map(([brand, pct]) => 
              `<tr style="border-bottom:1px solid #eee;"><td><strong>${brand}</strong></td><td style="text-align:right;">${pct}</td></tr>`
            ).join('')}
          </table>
        </td></tr>
        
        <!-- Footer -->
        <tr><td style="background-color:${PRIMARY_COLOR};padding:20px 32px;text-align:center;">
          <p style="color:#ccccdd;margin:0;font-size:12px;">Powered by AI Brand Intelligence | Managed by Your MSP</p>
          <p style="color:#999;margin:8px 0 0;font-size:11px;">This digest was automatically generated. Data sourced from social media, news, blogs, and forums.</p>
        </td></tr>
        
      </table>
    </td></tr>
  </table>
</body>
</html>
`;

return {
  json: {
    emailHtml,
    aiAnalysis,
    stats,
    weekStart,
    weekEnd,
    topPositive,
    topNegative
  }
};

// Alert Urgency Classifier - Configurable per client
// Place this in an n8n Function node

// ===== CLIENT-SPECIFIC CONFIGURATION =====
const CONFIG = {
  // Crisis keywords trigger immediate critical alerts
  crisisKeywords: [
    'lawsuit', 'scandal', 'recall', 'hack', 'breach', 'fraud',
    'fired', 'boycott', 'investigation', 'class action', 'data leak',
    'discrimination', 'harassment', 'SEC', 'FDA warning'
  ],
  
  // Tier 1 publications - mentions here are always high priority
  tier1Sources: [
    'nytimes.com', 'wsj.com', 'bbc.com', 'reuters.com', 'bloomberg.com',
    'techcrunch.com', 'theverge.com', 'mashable.com', 'adweek.com',
    'adage.com', 'marketingweek.com', 'digiday.com'
  ],
  
  // Thresholds
  criticalReachThreshold: 10000,  // Negative + this reach = critical
  highReachThreshold: 1000,       // Negative + this reach = high
  highReachAnysentiment: 5000,    // Any sentiment + this reach = high
  
  // Mention volume spike detection (3x rolling average)
  spikeMultiplier: 3.0
};

// ===== CLASSIFICATION LOGIC =====
function classifyMention(mention) {
  const content = (mention.content || '').toLowerCase();
  const reach = parseInt(mention.reach) || 0;
  const sentiment = mention.sentiment || 'Neutral';
  const source = (mention.platform || '').toLowerCase();
  const url = (mention.url || '').toLowerCase();
  
  let urgency = 'standard';
  let reasons = [];
  
  // Check crisis keywords
  const foundCrisis = CONFIG.crisisKeywords.filter(kw => content.includes(kw));
  if (foundCrisis.length > 0) {
    urgency = 'critical';
    reasons.push(`Crisis keyword detected: ${foundCrisis.join(', ')}`);
  }
  
  // Check negative + high reach
  if (sentiment === 'Negative' && reach > CONFIG.criticalReachThreshold) {
    urgency = 'critical';
    reasons.push(`Negative sentiment with reach ${reach.toLocaleString()}`);
  }
  
  // Check Tier 1 source
  const isTier1 = CONFIG.tier1Sources.some(s => url.includes(s));
  if (isTier1) {
    if (urgency !== 'critical') urgency = 'high';
    reasons.push(`Tier 1 source: ${url}`);
  }
  
  // Check negative + moderate reach
  if (sentiment === 'Negative' && reach > CONFIG.highReachThreshold && urgency === 'standard') {
    urgency = 'high';
    reasons.push(`Negative sentiment with reach ${reach.toLocaleString()}`);
  }
  
  // Check any sentiment + very high reach
  if (reach > CONFIG.highReachAnysentiment && urgency === 'standard') {
    urgency = 'high';
    reasons.push(`High reach mention: ${reach.toLocaleString()}`);
  }
  
  return {
    ...mention,
    urgency,
    alert_reasons: reasons.join('; ') || 'Standard monitoring - included in weekly digest'
  };
}

// Process the incoming mention
const mention = $input.item.json;
const classified = classifyMention(mention);

return { json: classified };

// Competitor Share-of-Voice Calculator
// n8n Function Node - runs as part of the Weekly Digest workflow

const mentions = $input.all().map(i => i.json);

// Group mentions by brand/competitor
const brandGroups = {};
mentions.forEach(m => {
  const brand = m.brand_or_competitor || 'Unknown';
  if (!brandGroups[brand]) {
    brandGroups[brand] = {
      name: brand,
      mentionCount: 0,
      totalReach: 0,
      positive: 0,
      negative: 0,
      neutral: 0,
      platforms: {},
      topMentions: []
    };
  }
  const group = brandGroups[brand];
  group.mentionCount++;
  group.totalReach += parseInt(m.reach) || 0;
  
  if (m.sentiment === 'Positive') group.positive++;
  else if (m.sentiment === 'Negative') group.negative++;
  else group.neutral++;
  
  const platform = m.platform || 'Unknown';
  group.platforms[platform] = (group.platforms[platform] || 0) + 1;
  
  // Track top mentions by reach
  group.topMentions.push({ content: m.content, reach: parseInt(m.reach) || 0, url: m.url });
});

// Calculate share of voice
const totalMentions = mentions.length;
const shareOfVoice = {};
const competitorReport = [];

for (const [brand, data] of Object.entries(brandGroups)) {
  const sovPct = totalMentions > 0 ? ((data.mentionCount / totalMentions) * 100) : 0;
  shareOfVoice[brand] = sovPct.toFixed(1) + '%';
  
  // Sort top mentions by reach, keep top 3
  data.topMentions.sort((a, b) => b.reach - a.reach);
  const notable = data.topMentions.slice(0, 3).map(m => m.content.substring(0, 100)).join(' | ');
  
  competitorReport.push({
    date: new Date().toISOString().split('T')[0],
    competitor_name: brand,
    mention_count: data.mentionCount,
    avg_sentiment: data.mentionCount > 0 
      ? ((data.positive - data.negative) / data.mentionCount).toFixed(2) 
      : '0.00',
    share_of_voice_pct: sovPct.toFixed(1),
    notable_mentions: notable,
    positive_count: data.positive,
    negative_count: data.negative,
    total_reach: data.totalReach,
    top_platform: Object.entries(data.platforms).sort((a, b) => b[1] - a[1])[0]?.[0] || 'N/A'
  });
}

// Sort by share of voice descending
competitorReport.sort((a, b) => parseFloat(b.share_of_voice_pct) - parseFloat(a.share_of_voice_pct));

return {
  json: {
    shareOfVoice,
    competitorReport,
    totalMentionsAnalyzed: totalMentions,
    brandGroups // Pass full data to next node for GPT analysis
  }
};

cd ~/n8n-brand-monitor && docker compose pull n8n && docker compose up -d n8n