Claude Code + adlibrary API: End-to-End Competitor Intelligence Workflows

#!/usr/bin/env node
// competitor-monitor.mjs — run via: node competitor-monitor.mjs
// Schedule: cron 0 9 * * * /usr/local/bin/node /scripts/competitor-monitor.mjs

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

const ADLIBRARY_KEY = process.env.ADLIBRARY_KEY;
const SLACK_WEBHOOK = process.env.SLACK_WEBHOOK;
const BRAND_SLUG = 'rivals-brand-name'; // target brand slug

async function fetchRecentAds(brandSlug, hours = 24) {
  const since = new Date(Date.now() - hours * 3600 * 1000).toISOString();
  const res = await fetch(
    `https://adlibrary.com/api/ads?brand=${brandSlug}&createdAfter=${since}&limit=50`,
    { headers: { Authorization: `Bearer ${ADLIBRARY_KEY}` } }
  );
  return res.json();
}

async function analyzeWithClaude(ads) {
  const client = new Anthropic();
  const msg = await client.messages.create({
    model: 'claude-opus-4-5',
    max_tokens: 1024,
    messages: [{
      role: 'user',
      content: `Analyze these ${ads.length} new competitor ads from the last 24 hours.
Output JSON with: { "volume_change": "up|down|flat", "new_angles": ["..."], "dominant_format": "video|static|carousel", "urgency": "high|medium|low", "summary": "2 sentences max" }

Ads: ${JSON.stringify(ads.map(a => ({ headline: a.headline, body: a.body, format: a.format })))}`,
    }],
  });
  return JSON.parse(msg.content[0].text);
}

async function sendSlackAlert(analysis, adCount) {
  const color = analysis.urgency === 'high' ? '#E84631' : '#36a64f';
  await fetch(SLACK_WEBHOOK, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      attachments: [{
        color,
        title: `Competitor Monitor: ${adCount} new ads detected`,
        text: analysis.summary,
        fields: [
          { title: 'Volume', value: analysis.volume_change, short: true },
          { title: 'Format', value: analysis.dominant_format, short: true },
          { title: 'New Angles', value: analysis.new_angles.join(', ') },
        ],
      }],
    }),
  });
}

const ads = await fetchRecentAds(BRAND_SLUG);
if (ads.docs?.length > 0) {
  const analysis = await analyzeWithClaude(ads.docs);
  await sendSlackAlert(analysis, ads.docs.length);
  console.log('Alert sent:', analysis.urgency);
} else {
  console.log('No new ads in last 24h');
}

// category-teardown.mjs
import Anthropic from '@anthropic-ai/sdk';
import fetch from 'node-fetch';

const client = new Anthropic();

async function getCategoryAds(categorySlug, limit = 200) {
  const res = await fetch(
    `https://adlibrary.com/api/ads?category=${categorySlug}&limit=${limit}&sort=-createdAt`,
    { headers: { Authorization: `Bearer ${process.env.ADLIBRARY_KEY}` } }
  );
  const data = await res.json();
  return data.docs || [];
}

function chunkArray(arr, size) {
  return Array.from({ length: Math.ceil(arr.length / size) }, (_, i) =>
    arr.slice(i * size, i * size + size)
  );
}

async function analyzeChunk(ads, chunkIndex) {
  const msg = await client.messages.create({
    model: 'claude-opus-4-5',
    max_tokens: 2048,
    messages: [{
      role: 'user',
      content: `Analyze this batch of ${ads.length} ads from the same product category.
For each ad, extract:
- hook_type: question | pain_point | social_proof | curiosity | direct_offer
- cta_pattern: urgency | soft | none
- primary_claim: one phrase max
- format: video | static | carousel

Return a JSON array. One object per ad.

Ads: ${JSON.stringify(ads.map((a, i) => ({ id: i, headline: a.headline, body: a.body?.slice(0, 200) })))}`,
    }],
  });
  return JSON.parse(msg.content[0].text);
}

const ads = await getCategoryAds('meal-delivery');
const chunks = chunkArray(ads, 20);

// Run in parallel — respect rate limits with a small concurrency cap
const results = [];
for (let i = 0; i < chunks.length; i += 3) {
  const batch = chunks.slice(i, i + 3);
  const batchResults = await Promise.all(batch.map((chunk, j) => analyzeChunk(chunk, i + j)));
  results.push(...batchResults.flat());
}

// Aggregate
const hookCounts = results.reduce((acc, r) => {
  acc[r.hook_type] = (acc[r.hook_type] || 0) + 1;
  return acc;
}, {});

console.log('Category teardown complete');
console.log('Hook distribution:', hookCounts);
console.log(`Total analyzed: ${results.length} ads`);

// hook-extractor.mjs
const HOOK_PROMPT = `You are extracting hook patterns from ad copy.

Classify the opening hook into exactly ONE of:
- PAIN_AGITATE: opens by naming a specific painful situation
- SOCIAL_PROOF: opens with numbers, results, or third-party validation
- CURIOSITY_GAP: withholds information to create tension
- DIRECT_OFFER: leads with price, discount, or concrete value
- IDENTITY_CLAIM: opens with who the ad is for ("For founders who...")
- CONTRARIAN: opens by challenging a common belief
- SCENARIO: opens with a specific real-world moment

Return JSON: { "hook_type": "<TYPE>", "hook_text": "<first sentence of headline/copy>", "confidence": 0-1 }

Ad headline: {HEADLINE}
Ad body (first 100 chars): {BODY}`;

async function extractHook(client, ad) {
  const prompt = HOOK_PROMPT
    .replace('{HEADLINE}', ad.headline || '')
    .replace('{BODY}', (ad.body || '').slice(0, 100));

  const msg = await client.messages.create({
    model: 'claude-haiku-4-5', // Use Haiku for extraction — cheaper, fast enough
    max_tokens: 256,
    messages: [{ role: 'user', content: prompt }],
  });
  return JSON.parse(msg.content[0].text);
}

// monthly-report.mjs
async function generateCategoryReport(client, categoryData) {
  const msg = await client.messages.create({
    model: 'claude-opus-4-5',
    max_tokens: 4096,
    messages: [{
      role: 'user',
      content: `Generate a monthly competitive landscape report for the "${categoryData.name}" category.

Data from the past 30 days:
- Total ads tracked: ${categoryData.totalAds}
- Brands active: ${categoryData.brands.length}
- Brand volume breakdown: ${JSON.stringify(categoryData.brandVolumes)}
- Hook type distribution: ${JSON.stringify(categoryData.hookDistribution)}
- New brands (first appearance this month): ${categoryData.newBrands.join(', ')}
- Dominant formats: ${JSON.stringify(categoryData.formatBreakdown)}

Write a structured markdown report with sections:
1. Executive summary (3 bullet points max)
2. Volume shifts (who increased/decreased spend signals)
3. Creative patterns (which hooks are rising/falling)
4. New entrants analysis
5. Whitespace opportunities (what the category is NOT doing)

Be direct. Name specific brands. Flag the 2-3 most actionable findings.`,
    }],
  });
  return msg.content[0].text;
}

// new-competitor-detector.mjs
import { readFileSync, writeFileSync } from 'fs';
import Anthropic from '@anthropic-ai/sdk';
import fetch from 'node-fetch';

const STATE_FILE = '/tmp/known-brands.json';

function loadKnownBrands() {
  try {
    return new Set(JSON.parse(readFileSync(STATE_FILE, 'utf8')));
  } catch {
    return new Set();
  }
}

function saveKnownBrands(brands) {
  writeFileSync(STATE_FILE, JSON.stringify([...brands]));
}

async function detectNewEntrants(categorySlug) {
  const client = new Anthropic();
  const knownBrands = loadKnownBrands();

  const res = await fetch(
    `https://adlibrary.com/api/ads?category=${categorySlug}&limit=500&sort=-createdAt`,
    { headers: { Authorization: `Bearer ${process.env.ADLIBRARY_KEY}` } }
  );
  const data = await res.json();
  const currentBrands = new Set(data.docs?.map(ad => ad.brand?.slug).filter(Boolean));

  const newBrands = [...currentBrands].filter(b => !knownBrands.has(b));

  if (newBrands.length > 0) {
    // Get their ads for Claude to profile
    const newBrandAds = data.docs.filter(ad => newBrands.includes(ad.brand?.slug));

    const msg = await client.messages.create({
      model: 'claude-opus-4-5',
      max_tokens: 1024,
      messages: [{
        role: 'user',
        content: `Profile these new competitors just detected in the "${categorySlug}" category.
For each brand, give: positioning angle, target audience (1 sentence), aggression level (1-5), threat level (low/medium/high).

New brands and their ads: ${JSON.stringify(
          newBrands.map(brand => ({
            brand,
            ads: newBrandAds
              .filter(a => a.brand?.slug === brand)
              .slice(0, 5)
              .map(a => ({ headline: a.headline, body: a.body?.slice(0, 150) })),
          }))
        )}`,
      }],
    });

    console.log('New competitors detected:', newBrands);
    console.log('Analysis:', msg.content[0].text);
  }

  saveKnownBrands(new Set([...knownBrands, ...currentBrands]));
  return newBrands;
}

await detectNewEntrants('meal-delivery');