crawlforge-mcp-server 3.0.18 → 3.4.0

package/src/tools/search/searchWeb.js

@@ -4,11 +4,14 @@ import { CacheManager } from '../../core/cache/CacheManager.js';
 import { QueryExpander } from './queryExpander.js';
 import { ResultRanker } from './ranking/ResultRanker.js';
 import { ResultDeduplicator } from './ranking/ResultDeduplicator.js';
+import { SearchResultCache } from './ranking/SearchResultCache.js';
 import LocalizationManager from '../../core/LocalizationManager.js';
 import { isCreatorModeVerified } from '../../core/creatorMode.js';
+import { searchViaSearxng } from './providers/searxng.js';
 
 const SearchWebSchema = z.object({
   query: z.string().min(1),
+  provider: z.enum(['crawlforge', 'searxng']).optional().default('crawlforge'),
   limit: z.number().min(1).max(100).optional().default(10),
   offset: z.number().min(0).optional().default(0),
   lang: z.string().optional().default('en'),
@@ -92,13 +95,16 @@ export class SearchWebTool {
     }
 
     this.cache = cacheEnabled ? new CacheManager({ ttl: cacheTTL }) : null;
-    
+
     // Initialize query expander
     this.queryExpander = new QueryExpander(expanderOptions);
-    
-    // Initialize ranking and deduplication systems
-    this.resultRanker = new ResultRanker({ cacheEnabled, cacheTTL, ...rankingOptions });
-    this.resultDeduplicator = new ResultDeduplicator({ cacheEnabled, cacheTTL, ...deduplicationOptions });
+
+    // Shared cache for ranking + deduplication — avoids two separate LRU instances
+    const sharedRankingCache = new SearchResultCache({ ttl: cacheTTL, enabled: cacheEnabled });
+
+    // Initialize ranking and deduplication systems (both share the same cache)
+    this.resultRanker = new ResultRanker({ cacheEnabled, cacheTTL, sharedCache: sharedRankingCache, ...rankingOptions });
+    this.resultDeduplicator = new ResultDeduplicator({ cacheEnabled, cacheTTL, sharedCache: sharedRankingCache, ...deduplicationOptions });
     
     // Initialize localization manager
     this.localizationManager = new LocalizationManager({
@@ -110,7 +116,13 @@ export class SearchWebTool {
   async execute(params) {
     try {
       const validated = SearchWebSchema.parse(params);
-      
+
+      // --- SearXNG provider short-circuit ---
+      if (validated.provider === 'searxng') {
+        return await this._executeViaSearxng(validated);
+      }
+      // --- end SearXNG short-circuit ---
+
       // Apply localization if specified
       let localizedParams = validated;
       if (validated.localization) {
@@ -336,6 +348,100 @@ export class SearchWebTool {
     }
   }
 
+  /**
+   * Execute search via a self-hosted SearXNG instance.
+   * Results are normalised to the same shape as the CrawlForge/Google path.
+   *
+   * @param {Object} validated - Parsed & validated parameters from SearchWebSchema
+   * @returns {Promise<Object>} Standard search_web response object
+   */
+  async _executeViaSearxng(validated) {
+    // page is 1-based; offset is 0-based items, so map via limit
+    const page = Math.floor(validated.offset / validated.limit) + 1;
+
+    const adapterResult = await searchViaSearxng({
+      query: validated.query,
+      limit: validated.limit,
+      page,
+      safeSearch: validated.safe_search,
+      language: validated.lang
+    });
+
+    // Run through shared post-processing (deduplication, ranking)
+    let processedResults = await this.processResults(adapterResult);
+
+    let deduplicationInfo = null;
+    if (validated.enable_deduplication && processedResults.length > 1) {
+      const dedupeOptions = validated.deduplication_thresholds
+        ? { thresholds: validated.deduplication_thresholds }
+        : {};
+      const originalCount = processedResults.length;
+      processedResults = await this.resultDeduplicator.deduplicateResults(
+        processedResults,
+        dedupeOptions
+      );
+      deduplicationInfo = {
+        originalCount,
+        finalCount: processedResults.length,
+        duplicatesRemoved: originalCount - processedResults.length,
+        deduplicationRate:
+          ((originalCount - processedResults.length) / originalCount * 100).toFixed(1) + '%'
+      };
+    }
+
+    let rankingInfo = null;
+    if (validated.enable_ranking && processedResults.length > 1) {
+      const rankingOptions = validated.ranking_weights
+        ? { weights: validated.ranking_weights }
+        : {};
+      processedResults = await this.resultRanker.rankResults(
+        processedResults,
+        validated.query,
+        rankingOptions
+      );
+      rankingInfo = {
+        algorithmsUsed: ['bm25', 'semantic', 'authority', 'freshness'],
+        weightsApplied: this.resultRanker.options.weights,
+        totalResults: processedResults.length
+      };
+    }
+
+    if (!validated.include_ranking_details) {
+      processedResults = processedResults.map(({ rankingDetails, ...r }) => r);
+    }
+    if (!validated.include_deduplication_details) {
+      processedResults = processedResults.map(({ deduplicationInfo: _d, ...r }) => r);
+    }
+
+    return {
+      query: validated.query,
+      results: processedResults,
+      total_results: adapterResult.searchInformation?.totalResults || 0,
+      search_time: adapterResult.searchInformation?.searchTime || 0,
+      offset: validated.offset,
+      limit: validated.limit,
+      cached: false,
+      provider: {
+        name: 'searxng',
+        backend: 'SearXNG (self-hosted)',
+        instanceUrl: process.env.CRAWLFORGE_SEARXNG_URL || null,
+        capabilities: {
+          requiresApiKey: false,
+          supportsPagination: true,
+          supportsLanguageFilter: true,
+          supportsSafeSearch: true
+        }
+      },
+      localization: null,
+      processing: {
+        ranking: rankingInfo,
+        deduplication: deduplicationInfo,
+        query_expansion: null,
+        localization_applied: false
+      }
+    };
+  }
+
   async processResults(searchResults) {
     if (!searchResults.items || searchResults.items.length === 0) {
       return [];

package/src/tools/tracking/trackChanges/differ.js

@@ -0,0 +1,98 @@
+/**
+ * TrackChanges — differ module.
+ * URL content fetching and history/stat helper functions.
+ */
+
+/**
+ * Fetch the HTML/text content of a URL with change-tracking headers.
+ * @param {string} url
+ * @returns {Promise<{ content: string, metadata: Object }>}
+ */
+export async function fetchContent(url) {
+  try {
+    const response = await fetch(url, {
+      headers: {
+        'User-Agent': 'MCP-WebScraper-ChangeTracker/3.0',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'Accept-Language': 'en-US,en;q=0.5',
+        'Accept-Encoding': 'gzip, deflate',
+        'Cache-Control': 'no-cache'
+      },
+      timeout: 30000
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    const content = await response.text();
+
+    return {
+      content,
+      metadata: {
+        statusCode: response.status,
+        contentType: response.headers.get('content-type'),
+        contentLength: content.length,
+        lastModified: response.headers.get('last-modified'),
+        etag: response.headers.get('etag'),
+        fetchedAt: Date.now()
+      }
+    };
+  } catch (error) {
+    throw new Error(`Failed to fetch content: ${error.message}`);
+  }
+}
+
+/**
+ * Merge change-tracker history entries with snapshot history entries.
+ * Deduplicates by timestamp proximity (within 60 s).
+ */
+export function mergeHistoryData(changeHistory, snapshotHistory) {
+  const merged = [];
+
+  changeHistory.forEach(entry => {
+    merged.push({ ...entry, source: 'change_tracker', hasSnapshot: false });
+  });
+
+  snapshotHistory.forEach(entry => {
+    const existing = merged.find(m => Math.abs(m.timestamp - entry.timestamp) < 60000);
+    if (existing) {
+      existing.hasSnapshot = true;
+      existing.snapshotId = entry.snapshotId;
+    } else {
+      merged.push({ ...entry, source: 'snapshot', hasSnapshot: true });
+    }
+  });
+
+  return merged.sort((a, b) => b.timestamp - a.timestamp);
+}
+
+/** Return true if entry.significance is at or above the filter level. */
+export function matchesSignificanceFilter(entry, filter) {
+  const levels = ['none', 'minor', 'moderate', 'major', 'critical'];
+  return levels.indexOf(entry.significance || 'none') >= levels.indexOf(filter);
+}
+
+/** Return true if significance meets the notification threshold. */
+export function meetsNotificationThreshold(significance, threshold) {
+  const levels = ['none', 'minor', 'moderate', 'major', 'critical'];
+  return levels.indexOf(significance) >= levels.indexOf(threshold);
+}
+
+export function calculateAverageInterval(changeHistory) {
+  if (changeHistory.length < 2) return null;
+  let total = 0;
+  for (let i = 1; i < changeHistory.length; i++) {
+    total += changeHistory[i - 1].timestamp - changeHistory[i].timestamp;
+  }
+  return total / (changeHistory.length - 1);
+}
+
+export function calculateSignificanceDistribution(changeHistory) {
+  const dist = { none: 0, minor: 0, moderate: 0, major: 0, critical: 0 };
+  changeHistory.forEach(entry => {
+    const sig = entry.significance || 'none';
+    if (Object.prototype.hasOwnProperty.call(dist, sig)) dist[sig]++;
+  });
+  return dist;
+}

package/src/tools/tracking/trackChanges/index.js

@@ -0,0 +1,432 @@
+/**
+ * TrackChanges — entry-point (index.js).
+ *
+ * Preserves the same exports as the original single-file trackChanges.js:
+ *   export class TrackChangesTool
+ *   export default TrackChangesTool
+ *   export const trackChangesTool          (singleton)
+ *
+ * Handler logic ≤ 150 LOC here; heavy work delegated to:
+ *   schema.js   — Zod input schema
+ *   differ.js   — fetch, merge-history, stat helpers
+ *   monitor.js  — polling monitor lifecycle
+ *   notifier.js — webhook / email / Slack notifications
+ */
+
+import { EventEmitter } from 'events';
+import ChangeTracker from '../../../core/ChangeTracker.js';
+import SnapshotManager from '../../../core/SnapshotManager.js';
+import CacheManager from '../../../core/cache/CacheManager.js';
+import { TrackChangesSchema } from './schema.js';
+import { fetchContent, mergeHistoryData, matchesSignificanceFilter, calculateAverageInterval, calculateSignificanceDistribution } from './differ.js';
+import { performMonitoringCheck, stopMonitor } from './monitor.js';
+import { sendNotifications } from './notifier.js';
+
+export class TrackChangesTool extends EventEmitter {
+  constructor(options = {}) {
+    super();
+
+    this.options = {
+      cacheEnabled: true,
+      cacheTTL: 3600000,
+      snapshotStorageDir: './snapshots',
+      enableRealTimeMonitoring: true,
+      maxConcurrentMonitors: 50,
+      defaultPollingInterval: 300000,
+      ...options
+    };
+
+    this.changeTracker = new ChangeTracker({
+      enableRealTimeTracking: this.options.enableRealTimeMonitoring,
+      enableSemanticAnalysis: false,
+      contentSimilarityThreshold: 0.8
+    });
+
+    this.snapshotManager = new SnapshotManager({
+      storageDir: this.options.snapshotStorageDir,
+      enableCompression: true,
+      enableDeltaStorage: true,
+      cacheEnabled: this.options.cacheEnabled
+    });
+
+    this.cache = this.options.cacheEnabled
+      ? new CacheManager({ ttl: this.options.cacheTTL })
+      : null;
+
+    this.activeMonitors = new Map();
+    this.monitorStats = new Map();
+
+    this.initialize();
+  }
+
+  async initialize() {
+    try {
+      await this.snapshotManager.initialize();
+      this._setupEventHandlers();
+      this.emit('initialized');
+    } catch (error) {
+      this.emit('error', { operation: 'initialize', error: error.message });
+      throw error;
+    }
+  }
+
+  _setupEventHandlers() {
+    this.changeTracker.on('changeDetected', async (changeRecord) => {
+      if (changeRecord.significance !== 'none') {
+        try {
+          await this.snapshotManager.storeSnapshot(
+            changeRecord.url,
+            changeRecord.details.current || '',
+            { changes: changeRecord.details, significance: changeRecord.significance, changeType: changeRecord.changeType }
+          );
+        } catch (error) {
+          this.emit('error', { operation: 'storeChangeSnapshot', url: changeRecord.url, error: error.message });
+        }
+      }
+    });
+
+    this.changeTracker.on('baselineCreated', (baseline) => this.emit('baselineCreated', baseline));
+    this.snapshotManager.on('snapshotStored', (snapshot) => this.emit('snapshotStored', snapshot));
+    this.snapshotManager.on('error', (error) => this.emit('error', error));
+  }
+
+  async execute(params) {
+    try {
+      const validated = TrackChangesSchema.parse(params);
+      const { operation } = validated;
+
+      switch (operation) {
+        case 'create_baseline':         return await this.createBaseline(validated);
+        case 'compare':                 return await this.compareWithBaseline(validated);
+        case 'monitor':                 return await this.setupMonitoring(validated);
+        case 'get_history':             return await this.getChangeHistory(validated);
+        case 'get_stats':               return await this.getStatistics(validated);
+        case 'create_scheduled_monitor':return await this.createScheduledMonitor(validated);
+        case 'stop_scheduled_monitor':  return await this.stopScheduledMonitor(validated);
+        case 'get_dashboard':           return await this.getMonitoringDashboard(validated);
+        case 'export_history':          return await this.exportHistoricalData(validated);
+        case 'create_alert_rule':       return await this.createAlertRule(validated);
+        case 'generate_trend_report':   return await this.generateTrendReport(validated);
+        case 'get_monitoring_templates':return await this.getMonitoringTemplates(validated);
+        default:                        throw new Error(`Unknown operation: ${operation}`);
+      }
+    } catch (error) {
+      return { success: false, error: error.message, timestamp: Date.now() };
+    }
+  }
+
+  async createBaseline(params) {
+    const { url, content, html, trackingOptions, storageOptions = {} } = params;
+    const enableSnapshots = storageOptions.enableSnapshots !== false;
+
+    let sourceContent = content || html;
+    let fetchMeta = {};
+    if (!sourceContent) {
+      const r = await fetchContent(url);
+      sourceContent = r.content;
+      fetchMeta = r.metadata;
+    }
+    if (!sourceContent || typeof sourceContent !== 'string') throw new Error('Invalid content');
+
+    const baseline = await this.changeTracker.createBaseline(url, sourceContent, trackingOptions);
+    let snapshotInfo = null;
+    if (enableSnapshots) {
+      snapshotInfo = await this.snapshotManager.storeSnapshot(url, sourceContent, { ...fetchMeta, baseline: true, trackingOptions });
+    }
+
+    return {
+      success: true, operation: 'create_baseline', url,
+      baseline: {
+        version: baseline.version,
+        contentHash: baseline.analysis?.hashes?.page,
+        sections: Object.keys(baseline.analysis?.hashes?.sections || {}).length,
+        elements: Object.keys(baseline.analysis?.hashes?.elements || {}).length,
+        createdAt: baseline.timestamp,
+        options: trackingOptions
+      },
+      snapshot: snapshotInfo, timestamp: Date.now()
+    };
+  }
+
+  async compareWithBaseline(params) {
+    const { url, content, html, trackingOptions, storageOptions = {}, notificationOptions } = params;
+    const enableSnapshots = storageOptions.enableSnapshots !== false;
+
+    let currentContent = content || html;
+    let fetchMeta = {};
+    if (!currentContent) {
+      const r = await fetchContent(url);
+      currentContent = r.content;
+      fetchMeta = r.metadata;
+    }
+    if (!currentContent || typeof currentContent !== 'string') throw new Error('Invalid content');
+
+    const comparisonResult = await this.changeTracker.compareWithBaseline(url, currentContent, trackingOptions);
+
+    let snapshotInfo = null;
+    if (comparisonResult.hasChanges && enableSnapshots) {
+      snapshotInfo = await this.snapshotManager.storeSnapshot(url, currentContent, {
+        ...fetchMeta, changes: comparisonResult.summary, significance: comparisonResult.significance
+      });
+    }
+
+    if (comparisonResult.hasChanges && notificationOptions) {
+      await sendNotifications(url, comparisonResult, notificationOptions, this);
+    }
+
+    return {
+      success: true, operation: 'compare', url,
+      hasChanges: comparisonResult.hasChanges,
+      significance: comparisonResult.significance,
+      changeType: comparisonResult.changeType,
+      summary: comparisonResult.summary,
+      details: comparisonResult.details,
+      metrics: comparisonResult.metrics,
+      recommendations: comparisonResult.recommendations,
+      snapshot: snapshotInfo, timestamp: Date.now()
+    };
+  }
+
+  async setupMonitoring(params) {
+    const { url, monitoringOptions, trackingOptions, storageOptions, notificationOptions } = params;
+
+    if (this.activeMonitors.has(url)) {
+      clearInterval(this.activeMonitors.get(url).timer);
+    }
+
+    const deps = { changeTracker: this.changeTracker, snapshotManager: this.snapshotManager, emitter: this };
+
+    const monitorConfig = {
+      url,
+      options: { ...monitoringOptions, trackingOptions, storageOptions, notificationOptions },
+      stats: { started: Date.now(), checks: 0, changesDetected: 0, errors: 0, lastCheck: null, lastChange: null, averageResponseTime: 0 }
+    };
+
+    monitorConfig.timer = setInterval(
+      () => performMonitoringCheck(url, monitorConfig, deps),
+      monitoringOptions.interval
+    );
+
+    this.activeMonitors.set(url, monitorConfig);
+    this.monitorStats.set(url, monitorConfig.stats);
+
+    await performMonitoringCheck(url, monitorConfig, deps);
+
+    return {
+      success: true, operation: 'monitor', url,
+      monitoring: { enabled: true, interval: monitoringOptions.interval, notificationThreshold: monitoringOptions.notificationThreshold, startedAt: monitorConfig.stats.started },
+      timestamp: Date.now()
+    };
+  }
+
+  async getChangeHistory(params) {
+    const { url, queryOptions } = params;
+
+    const changeHistory = this.changeTracker.getChangeHistory(url, queryOptions.limit);
+    const snapshotHistory = await this.snapshotManager.getChangeHistory(url, queryOptions);
+    let combined = mergeHistoryData(changeHistory, snapshotHistory.history);
+
+    if (queryOptions.significanceFilter && queryOptions.significanceFilter !== 'all') {
+      combined = combined.filter(e => matchesSignificanceFilter(e, queryOptions.significanceFilter));
+    }
+
+    const start = queryOptions.offset || 0;
+    const end = start + (queryOptions.limit || 50);
+
+    return {
+      success: true, operation: 'get_history', url,
+      history: combined.slice(start, end),
+      pagination: { total: combined.length, limit: queryOptions.limit, offset: queryOptions.offset, hasMore: end < combined.length },
+      timespan: {
+        earliest: combined.length > 0 ? combined[combined.length - 1].timestamp : null,
+        latest: combined.length > 0 ? combined[0].timestamp : null,
+        totalEntries: combined.length
+      },
+      timestamp: Date.now()
+    };
+  }
+
+  async getStatistics(params) {
+    const { url } = params;
+    const monitoringStats = url ? this.monitorStats.get(url) : this._getAggregatedMonitoringStats();
+    let urlStats = null;
+    if (url) {
+      try {
+        const changeHistory = this.changeTracker.getChangeHistory(url, 100);
+        const snapshotHistory = await this.snapshotManager.querySnapshots({ url, limit: 100, includeContent: false });
+        urlStats = {
+          totalChanges: changeHistory.length,
+          totalSnapshots: snapshotHistory.snapshots.length,
+          lastChange: changeHistory.length > 0 ? changeHistory[0].timestamp : null,
+          averageChangeInterval: calculateAverageInterval(changeHistory),
+          significanceDistribution: calculateSignificanceDistribution(changeHistory),
+          isBeingMonitored: this.activeMonitors.has(url)
+        };
+      } catch (error) {
+        urlStats = { error: error.message };
+      }
+    }
+
+    return {
+      success: true, operation: 'get_stats', url: url || 'global',
+      stats: {
+        changeTracking: this.changeTracker.getStats(),
+        snapshotStorage: this.snapshotManager.getStats(),
+        monitoring: monitoringStats,
+        urlSpecific: urlStats,
+        system: { activeMonitors: this.activeMonitors.size, cacheEnabled: !!this.cache, cacheStats: this.cache ? this.cache.getStats() : null }
+      },
+      timestamp: Date.now()
+    };
+  }
+
+  async createScheduledMonitor(params) {
+    const { url, scheduledMonitorOptions, trackingOptions, notificationOptions } = params;
+    const schedule = scheduledMonitorOptions?.schedule || '0 */1 * * *';
+    const templateId = scheduledMonitorOptions?.templateId;
+    let monitorOptions = { ...trackingOptions };
+    if (templateId && this.changeTracker.monitoringTemplates.has(templateId)) {
+      monitorOptions = { ...this.changeTracker.monitoringTemplates.get(templateId).options, ...monitorOptions };
+    }
+    const result = await this.changeTracker.createScheduledMonitor(url, schedule, {
+      ...monitorOptions,
+      alertRules: { threshold: 'moderate', methods: ['webhook'], throttle: 600000, ...notificationOptions }
+    });
+    return { success: true, operation: 'create_scheduled_monitor', url, monitor: result, template: templateId ? this.changeTracker.monitoringTemplates.get(templateId)?.name : null, timestamp: Date.now() };
+  }
+
+  async stopScheduledMonitor(params) {
+    const { url } = params;
+    let stoppedMonitors = 0;
+    for (const [id, monitor] of this.changeTracker.scheduledMonitors.entries()) {
+      if (monitor.url === url) {
+        monitor.cronJob?.destroy();
+        monitor.status = 'stopped';
+        this.changeTracker.scheduledMonitors.delete(id);
+        stoppedMonitors++;
+      }
+    }
+    return { success: true, operation: 'stop_scheduled_monitor', url, stoppedMonitors, timestamp: Date.now() };
+  }
+
+  async getMonitoringDashboard(params) {
+    const { dashboardOptions } = params;
+    const dashboard = this.changeTracker.getMonitoringDashboard();
+    if (!dashboardOptions?.includeRecentAlerts) delete dashboard.recentAlerts;
+    if (!dashboardOptions?.includeTrends) delete dashboard.trends;
+    if (!dashboardOptions?.includeMonitorStatus) {
+      dashboard.monitors = dashboard.monitors.map(m => ({ id: m.id, url: m.url, status: m.status }));
+    }
+    return { success: true, operation: 'get_dashboard', dashboard, timestamp: Date.now() };
+  }
+
+  async exportHistoricalData(params) {
+    const { url, exportOptions } = params;
+    const exportData = await this.changeTracker.exportHistoricalData({ ...exportOptions, url });
+    return { success: true, operation: 'export_history', url: url || 'global', export: exportData, timestamp: Date.now() };
+  }
+
+  async createAlertRule(params) {
+    const { alertRuleOptions } = params;
+    const ruleId = alertRuleOptions?.ruleId || `custom_rule_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const rule = {
+      condition: this._parseCondition(alertRuleOptions?.condition || 'significance === "major"'),
+      actions: alertRuleOptions?.actions || ['webhook'],
+      throttle: alertRuleOptions?.throttle || 600000,
+      priority: alertRuleOptions?.priority || 'medium'
+    };
+    this.changeTracker.alertRules.set(ruleId, rule);
+    return { success: true, operation: 'create_alert_rule', ruleId, rule, timestamp: Date.now() };
+  }
+
+  async generateTrendReport(params) {
+    const report = await this.changeTracker.generateTrendAnalysisReport(params.url);
+    return { success: true, operation: 'generate_trend_report', report, timestamp: Date.now() };
+  }
+
+  async getMonitoringTemplates() {
+    const templates = {};
+    for (const [id, template] of this.changeTracker.monitoringTemplates.entries()) {
+      templates[id] = { name: template.name, frequency: template.frequency, options: template.options, alertRules: template.alertRules };
+    }
+    return { success: true, operation: 'get_monitoring_templates', templates, count: Object.keys(templates).length, timestamp: Date.now() };
+  }
+
+  // ── Public API ────────────────────────────────────────────────────────────────
+
+  stopMonitoring(url) {
+    if (!this.activeMonitors.has(url)) return false;
+    const monitorConfig = this.activeMonitors.get(url);
+    stopMonitor(url, monitorConfig, this);
+    this.activeMonitors.delete(url);
+    return true;
+  }
+
+  stopAllMonitoring() {
+    const urls = Array.from(this.activeMonitors.keys());
+    urls.forEach(url => this.stopMonitoring(url));
+    this.emit('allMonitoringStopped', { count: urls.length });
+    return urls.length;
+  }
+
+  getActiveMonitors() {
+    return Array.from(this.activeMonitors.keys()).map(url => ({
+      url,
+      config: this.activeMonitors.get(url).options,
+      stats: this.monitorStats.get(url)
+    }));
+  }
+
+  async shutdown() {
+    this.stopAllMonitoring();
+    await this.snapshotManager.shutdown();
+    await this.changeTracker.cleanup();
+    this.emit('shutdown');
+  }
+
+  // ── Private helpers ────────────────────────────────────────────────────────────
+
+  _getAggregatedMonitoringStats() {
+    const stats = { totalMonitors: this.activeMonitors.size, totalChecks: 0, totalChanges: 0, totalErrors: 0, averageResponseTime: 0, oldestMonitor: null, newestMonitor: null };
+    const all = Array.from(this.monitorStats.values());
+    if (all.length === 0) return stats;
+    stats.totalChecks = all.reduce((s, v) => s + v.checks, 0);
+    stats.totalChanges = all.reduce((s, v) => s + v.changesDetected, 0);
+    stats.totalErrors = all.reduce((s, v) => s + v.errors, 0);
+    stats.averageResponseTime = all.reduce((s, v) => s + v.averageResponseTime, 0) / all.length;
+    stats.oldestMonitor = Math.min(...all.map(v => v.started));
+    stats.newestMonitor = Math.max(...all.map(v => v.started));
+    return stats;
+  }
+
+  _parseCondition(conditionString) {
+    return (changeResult) => {
+      try {
+        if (conditionString.includes('significance')) {
+          const match = conditionString.match(/significance\s*===\s*["'](\w+)["']/);
+          if (match) return changeResult.significance === match[1];
+        }
+        return false;
+      } catch {
+        return false;
+      }
+    };
+  }
+}
+
+export default TrackChangesTool;
+
+// Singleton instance — kept for backward-compat with any code that imports it directly
+export const trackChangesTool = new TrackChangesTool();
+trackChangesTool.name = 'track_changes';
+trackChangesTool.validateParameters = (params) => TrackChangesSchema.parse(params);
+trackChangesTool.description = 'Track and analyze content changes with baseline capture, comparison, and monitoring capabilities';
+trackChangesTool.inputSchema = {
+  type: 'object',
+  properties: {
+    url: { type: 'string', description: 'URL to track for changes' },
+    operation: { type: 'string', description: 'Operation to perform: create_baseline, compare, monitor, get_history, get_stats' },
+    content: { type: 'string', description: 'Content to analyze or compare' }
+  },
+  required: ['url']
+};