Real-Time Competitive Intelligence with AI Agents

import { Client } from '@modelcontextprotocol/sdk/client/index.js';

const client = new Client({
  name: 'competitive-intel',
  version: '1.0.0',
});

interface CompetitorTarget {
  name: string;
  domain: string;
  pages: {
    pricing: string;
    changelog: string;
    blog: string;
    careers: string;
    integrations: string;
  };
  keywords: string[]; // Track mentions of these terms
}

const competitors: CompetitorTarget[] = [
  {
    name: 'Firecrawl',
    domain: 'firecrawl.dev',
    pages: {
      pricing: 'https://www.firecrawl.dev/pricing',
      changelog: 'https://www.firecrawl.dev/changelog',
      blog: 'https://www.firecrawl.dev/blog',
      careers: 'https://www.firecrawl.dev/careers',
      integrations: 'https://www.firecrawl.dev/integrations',
    },
    keywords: ['mcp', 'claude', 'scraping', 'api'],
  },
  {
    name: 'Apify',
    domain: 'apify.com',
    pages: {
      pricing: 'https://apify.com/pricing',
      changelog: 'https://apify.com/change-log',
      blog: 'https://blog.apify.com',
      careers: 'https://apify.com/jobs',
      integrations: 'https://apify.com/integrations',
    },
    keywords: ['web scraping', 'automation', 'ai', 'mcp'],
  },
];

interface ChangeAlert {
  competitor: string;
  page: string;
  significance: string;
  changes: string[];
  detectedAt: string;
}

async function monitorCompetitorPages(
  competitor: CompetitorTarget
): Promise<ChangeAlert[]> {
  const alerts: ChangeAlert[] = [];

  for (const [pageType, url] of Object.entries(competitor.pages)) {
    const result = await client.callTool({
      name: 'track_changes',
      arguments: {
        url,
        operation: 'compare',
        trackingOptions: {
          trackText: true,
          trackLinks: true,
          trackStructure: true,
          granularity: 'section',
          significanceThresholds: {
            minor: 0.1,
            moderate: 0.3,
            major: 0.5,
          },
        },
        storageOptions: {
          retainHistory: true,
          maxHistoryEntries: 100,
        },
      },
    });

    const changes = JSON.parse(result.content[0].text);

    if (changes.hasChanges && changes.significance !== 'minor') {
      alerts.push({
        competitor: competitor.name,
        page: pageType,
        significance: changes.significance,
        changes: changes.differences.map(
          (d: { type: string; summary: string }) => `${d.type}: ${d.summary}`
        ),
        detectedAt: new Date().toISOString(),
      });
    }
  }

  return alerts;
}

interface ContentInsight {
  url: string;
  topics: string[];
  sentiment: string;
  keyPhrases: string[];
  competitiveAngle: string;
}

async function analyzeCompetitorContent(
  url: string
): Promise<ContentInsight> {
  // Extract clean content
  const extracted = await client.callTool({
    name: 'extract_content',
    arguments: { url },
  });

  const content = JSON.parse(extracted.content[0].text);

  // Analyze for topics, sentiment, and key phrases
  const analysis = await client.callTool({
    name: 'analyze_content',
    arguments: {
      text: content.content,
    },
  });

  const result = JSON.parse(analysis.content[0].text);

  return {
    url,
    topics: result.topics || [],
    sentiment: result.sentiment || 'neutral',
    keyPhrases: result.keyPhrases || [],
    competitiveAngle: result.summary || '',
  };
}

async function researchCompetitor(competitorName: string) {
  const research = await client.callTool({
    name: 'deep_research',
    arguments: {
      topic: `${competitorName} product updates pricing changes 2026`,
      maxDepth: 5,
      maxUrls: 30,
      enableSourceVerification: true,
      enableConflictDetection: true,
      researchApproach: 'focused',
      credibilityThreshold: 0.5,
      sourceTypes: ['news', 'commercial', 'blog'],
    },
  });

  return JSON.parse(research.content[0].text);
}

async function generateWeeklyReport(
  alerts: ChangeAlert[],
  insights: ContentInsight[],
  research: Record<string, unknown>
) {
  const reportData = {
    period: 'Weekly CI Report',
    date: new Date().toISOString(),
    alerts,
    insights,
    research,
  };

  const summary = await client.callTool({
    name: 'summarize_content',
    arguments: {
      text: JSON.stringify(reportData, null, 2),
    },
  });

  return JSON.parse(summary.content[0].text);
}

// Run the complete CI pipeline
async function runWeeklyIntelligence() {
  const allAlerts: ChangeAlert[] = [];
  const allInsights: ContentInsight[] = [];

  for (const competitor of competitors) {
    // Check for changes
    const alerts = await monitorCompetitorPages(competitor);
    allAlerts.push(...alerts);

    // Analyze changed pages
    for (const alert of alerts) {
      const pageUrl = competitor.pages[
        alert.page as keyof typeof competitor.pages
      ];
      const insight = await analyzeCompetitorContent(pageUrl);
      allInsights.push(insight);
    }

    // Deep research on each competitor
    const research = await researchCompetitor(competitor.name);

    // Generate report
    const report = await generateWeeklyReport(
      allAlerts,
      allInsights,
      research
    );

    console.log(`\n=== ${competitor.name} Intelligence Report ===\n`);
    console.log(report.summary);
  }
}