构建一个 AI 驱动的价格监控系统

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

// Initialize the MCP client connected to CrawlForge
const client = new Client({
  name: 'price-monitor',
  version: '1.0.0',
});

// Discover all product pages on a competitor site
async function discoverProductPages(competitorUrl: string): Promise<string[]> {
  const siteMap = await client.callTool({
    name: 'map_site',
    arguments: {
      url: competitorUrl,
      max_urls: 500,
      include_metadata: true,
      group_by_path: true,
    },
  });

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

  // Filter for product and pricing pages
  const productPages = result.urls.filter((url: string) =>
    url.includes('/product') ||
    url.includes('/pricing') ||
    url.includes('/plans')
  );

  return productPages;
}

// Usage: discover pages for each competitor
const competitors = [
  'https://competitor-a.com',
  'https://competitor-b.com',
  'https://competitor-c.com',
];

for (const site of competitors) {
  const pages = await discoverProductPages(site);
  console.log(`Found ${pages.length} product pages on ${site}`);
}

interface PriceData {
  productName: string;
  price: string;
  currency: string;
  url: string;
  extractedAt: string;
}

async function extractPrices(urls: string[]): Promise<PriceData[]> {
  const results: PriceData[] = [];

  // Batch scrape all URLs for efficiency
  const batchResult = await client.callTool({
    name: 'batch_scrape',
    arguments: {
      urls: urls.map(url => ({
        url,
        selectors: {
          productName: 'h1.product-title, [data-testid="product-name"]',
          price: '.price-current, [data-testid="price"], .plan-price',
          currency: '.price-currency, [data-currency]',
        },
      })),
      maxConcurrency: 10,
      includeMetadata: true,
    },
  });

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

  for (const page of batch.results) {
    if (page.status === 'success') {
      results.push({
        productName: page.data.productName || 'Unknown',
        price: page.data.price || 'N/A',
        currency: page.data.currency || 'USD',
        url: page.url,
        extractedAt: new Date().toISOString(),
      });
    }
  }

  return results;
}

async function extractDynamicPricing(url: string) {
  const result = await client.callTool({
    name: 'scrape_with_actions',
    arguments: {
      url,
      actions: [
        // Wait for pricing to render
        { type: 'wait', selector: '.pricing-table', timeout: 5000 },
        // Click "Annual" toggle to see annual pricing
        { type: 'click', selector: '[data-billing="annual"]' },
        // Wait for prices to update
        { type: 'wait', timeout: 1000 },
        // Take a screenshot for verification
        { type: 'screenshot', description: 'Annual pricing view' },
      ],
      extractionOptions: {
        selectors: {
          plans: '.plan-card',
          prices: '.plan-price',
          features: '.plan-features li',
        },
        includeMetadata: true,
      },
    },
  });

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

async function detectPriceChanges(
  competitorUrl: string,
  currentPrices: PriceData[]
) {
  // Create or compare against baseline
  const changeResult = await client.callTool({
    name: 'track_changes',
    arguments: {
      url: competitorUrl,
      operation: 'compare',
      content: JSON.stringify(currentPrices),
      trackingOptions: {
        granularity: 'element',
        trackText: true,
        ignoreWhitespace: true,
        significanceThresholds: {
          minor: 0.05,    // <5% price change = minor
          moderate: 0.15,  // 5-15% = moderate
          major: 0.30,     // >15% = major alert
        },
      },
    },
  });

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

  if (changes.hasChanges) {
    console.log(`Price changes detected on ${competitorUrl}:`);
    for (const change of changes.differences) {
      console.log(`  ${change.field}: ${change.oldValue} -> ${change.newValue}`);
    }
  }

  return changes;
}

interface PriceAlert {
  competitor: string;
  product: string;
  oldPrice: string;
  newPrice: string;
  changePercent: number;
  severity: 'minor' | 'moderate' | 'major';
  detectedAt: string;
}

async function runDailyMonitoring(competitors: string[]): Promise<PriceAlert[]> {
  const alerts: PriceAlert[] = [];

  for (const competitorUrl of competitors) {
    // Step 1: Discover pages (weekly, cached)
    const pages = await discoverProductPages(competitorUrl);

    // Step 2: Extract current prices
    const prices = await extractPrices(pages);

    // Step 3: Detect changes
    const changes = await detectPriceChanges(competitorUrl, prices);

    // Step 4: Generate alerts for significant changes
    if (changes.hasChanges) {
      for (const diff of changes.differences) {
        const changePercent = calculatePercentChange(
          diff.oldValue,
          diff.newValue
        );

        alerts.push({
          competitor: competitorUrl,
          product: diff.field,
          oldPrice: diff.oldValue,
          newPrice: diff.newValue,
          changePercent,
          severity: changes.significance,
          detectedAt: new Date().toISOString(),
        });
      }
    }
  }

  return alerts;
}

function calculatePercentChange(oldVal: string, newVal: string): number {
  const old = parseFloat(oldVal.replace(/[^0-9.]/g, ''));
  const current = parseFloat(newVal.replace(/[^0-9.]/g, ''));
  return ((current - old) / old) * 100;
}