search-console-mcp 1.13.1 → 1.13.2

package/dist/bing/tools/analytics.js

@@ -177,3 +177,89 @@ export async function getPerformanceSummary(siteUrl, days = 28) {
         endDate: endDate.toISOString().split('T')[0]
     };
 }
+/**
+ * Detect rising or declining trends in Bing query performance.
+ *
+ * @param siteUrl - The URL of the site to analyze.
+ * @param options - Configuration including lookback period and click thresholds.
+ * @returns A list of queries showing significant momentum.
+ */
+export async function detectTrends(siteUrl, options = {}) {
+    const days = options.days || 28;
+    const threshold = options.threshold || 10;
+    const minClicks = options.minClicks || 100;
+    const limit = options.limit || 20;
+    const midPoint = Math.floor(days / 2);
+    const endDate = new Date();
+    endDate.setDate(endDate.getDate() - 2); // Data delay
+    const currentEndDate = new Date(endDate);
+    const currentStartDate = new Date(currentEndDate);
+    currentStartDate.setDate(currentStartDate.getDate() - midPoint + 1);
+    const previousEndDate = new Date(currentStartDate);
+    previousEndDate.setDate(previousEndDate.getDate() - 1);
+    const previousStartDate = new Date(previousEndDate);
+    previousStartDate.setDate(previousStartDate.getDate() - midPoint + 1);
+    const allStats = await getQueryStats(siteUrl);
+    const filterStats = (start, end) => {
+        const map = new Map();
+        allStats.forEach(stat => {
+            const d = new Date(stat.Date);
+            if (d >= start && d <= end) {
+                map.set(stat.Query, (map.get(stat.Query) || 0) + stat.Clicks);
+            }
+        });
+        return map;
+    };
+    const currentMap = filterStats(currentStartDate, currentEndDate);
+    const previousMap = filterStats(previousStartDate, previousEndDate);
+    const trends = [];
+    for (const [query, currClicks] of currentMap.entries()) {
+        const prevClicks = previousMap.get(query) || 0;
+        if (currClicks < minClicks && prevClicks < minClicks)
+            continue;
+        if (prevClicks > 0) {
+            const change = currClicks - prevClicks;
+            const percent = (change / prevClicks) * 100;
+            if (Math.abs(percent) >= threshold) {
+                trends.push({
+                    key: query,
+                    metric: 'clicks',
+                    change,
+                    changePercent: parseFloat(percent.toFixed(2)),
+                    trend: percent > 0 ? 'rising' : 'declining',
+                    currentValue: currClicks,
+                    previousValue: prevClicks
+                });
+            }
+        }
+        else if (currClicks >= minClicks) {
+            // Zero to Hero
+            trends.push({
+                key: query,
+                metric: 'clicks',
+                change: currClicks,
+                changePercent: 100,
+                trend: 'rising',
+                currentValue: currClicks,
+                previousValue: 0
+            });
+        }
+    }
+    // Also check for queries that dropped to zero
+    for (const [query, prevClicks] of previousMap.entries()) {
+        if (!currentMap.has(query) && prevClicks >= minClicks) {
+            trends.push({
+                key: query,
+                metric: 'clicks',
+                change: -prevClicks,
+                changePercent: -100,
+                trend: 'declining',
+                currentValue: 0,
+                previousValue: prevClicks
+            });
+        }
+    }
+    return trends
+        .sort((a, b) => Math.abs(b.change) - Math.abs(a.change))
+        .slice(0, limit);
+}

package/dist/bing/tools/sites-health.js

@@ -2,6 +2,7 @@ import * as bingSites from './sites.js';
 import * as bingSitemaps from './sitemaps.js';
 import * as bingAnalytics from './analytics.js';
 import * as bingCrawl from './crawl.js';
+import { limitConcurrency } from '../../common/concurrency.js';
 /**
  * Run a health check on a single Bing site.
  */
@@ -103,7 +104,7 @@ export async function healthCheck(siteUrl) {
     if (allSites.length === 0) {
         return [];
     }
-    const reports = await Promise.all(allSites.map((site) => checkSite(site.Url)));
+    const reports = await limitConcurrency(allSites, 5, (site) => checkSite(site.Url));
     const order = { critical: 0, warning: 1, healthy: 2 };
     return reports.sort((a, b) => (order[a.status] || 0) - (order[b.status] || 0));
 }

package/dist/ga4/tools/analytics.js

@@ -29,6 +29,9 @@ export async function batchQueryAnalytics(options) {
             return cached.promise;
         }
         if (now - cached.timestamp < CACHE_TTL_MS) {
+            // LRU: Refresh key position
+            analyticsCache.delete(cacheKey);
+            analyticsCache.set(cacheKey, cached);
             return cached.data;
         }
         analyticsCache.delete(cacheKey);
@@ -77,6 +80,9 @@ export async function queryAnalytics(options) {
             return cached.promise;
         }
         if (now - cached.timestamp < CACHE_TTL_MS) {
+            // LRU: Refresh key position
+            analyticsCache.delete(cacheKey);
+            analyticsCache.set(cacheKey, cached);
             return cached.data;
         }
         analyticsCache.delete(cacheKey);

package/dist/google/tools/advanced-analytics.js

@@ -158,7 +158,8 @@ export async function getTimeSeriesInsights(siteUrl, options = {}) {
         return {
             date: r.keys?.[dimensions.indexOf('date')] || '',
             dimensions: dimObj,
-            metrics: metricObj
+            metrics: metricObj,
+            original: r
         };
     }).sort((a, b) => a.date.localeCompare(b.date));
     // Support weekly granularity
@@ -166,33 +167,56 @@ export async function getTimeSeriesInsights(siteUrl, options = {}) {
         const weeklyData = {};
         data.forEach(d => {
             const date = new Date(d.date);
-            const day = date.getDay();
-            const diff = date.getDate() - day + (day === 0 ? -6 : 1); // Adjust to Monday
-            const monday = new Date(date.setDate(diff));
+            const day = date.getUTCDay();
+            const diff = date.getUTCDate() - day + (day === 0 ? -6 : 1); // Adjust to Monday
+            const monday = new Date(date);
+            monday.setUTCDate(diff);
             const weekKey = monday.toISOString().split('T')[0];
             if (!weeklyData[weekKey]) {
+                const initMetrics = {};
+                metrics.forEach(m => initMetrics[m] = 0);
                 weeklyData[weekKey] = {
                     date: weekKey,
                     dimensions: d.dimensions,
-                    metrics: { ...d.metrics }
+                    metrics: initMetrics,
+                    accumulators: { clicks: 0, impressions: 0, weightedPos: 0, count: 0 }
                 };
             }
-            else {
-                metrics.forEach(m => {
-                    if (m === 'position') {
-                        // For average position, we might need a weighted average, but simple average for now
-                        weeklyData[weekKey].metrics[m] = (weeklyData[weekKey].metrics[m] + d.metrics[m]) / 2;
-                    }
-                    else if (m === 'ctr') {
-                        weeklyData[weekKey].metrics[m] = (weeklyData[weekKey].metrics[m] + d.metrics[m]) / 2;
-                    }
-                    else {
-                        weeklyData[weekKey].metrics[m] += d.metrics[m];
-                    }
-                });
-            }
+            // Accumulate raw values
+            const entry = weeklyData[weekKey];
+            const r = d.original;
+            const clicks = r.clicks ?? 0;
+            const impressions = r.impressions ?? 0;
+            const position = r.position ?? 0;
+            entry.accumulators.clicks += clicks;
+            entry.accumulators.impressions += impressions;
+            entry.accumulators.weightedPos += (position * impressions);
+            entry.accumulators.count += 1;
         });
-        data = Object.values(weeklyData).sort((a, b) => a.date.localeCompare(b.date));
+        // Compute final weekly metrics
+        data = Object.values(weeklyData).map(w => {
+            const m = w.metrics;
+            const acc = w.accumulators;
+            const finalClicks = acc.clicks;
+            const finalImpressions = acc.impressions;
+            const finalCtr = finalImpressions > 0 ? finalClicks / finalImpressions : 0;
+            const finalPos = finalImpressions > 0 ? acc.weightedPos / finalImpressions : 0;
+            metrics.forEach(metric => {
+                if (metric === 'clicks')
+                    m[metric] = finalClicks;
+                else if (metric === 'impressions')
+                    m[metric] = finalImpressions;
+                else if (metric === 'ctr')
+                    m[metric] = finalCtr;
+                else if (metric === 'position')
+                    m[metric] = parseFloat(finalPos.toFixed(2));
+            });
+            return {
+                date: w.date,
+                dimensions: w.dimensions,
+                metrics: m
+            };
+        }).sort((a, b) => a.date.localeCompare(b.date));
     }
     // 1. Calculate Rolling Averages for EACH metric
     const history = data.map((d, i) => {

package/dist/google/tools/analytics.js

@@ -7,18 +7,17 @@ export function clearAnalyticsCache() {
 }
 function generateCacheKey(options) {
     const clone = { ...options };
-    // Dimensions order matters because it determines the order of keys in the response.
-    // We should NOT sort them.
-    /*
-    if (clone.dimensions) {
-      clone.dimensions = [...clone.dimensions].sort();
-    }
-    */
     if (clone.filters) {
         clone.filters = [...clone.filters].sort((a, b) => (a.dimension + a.operator + a.expression).localeCompare(b.dimension + b.operator + b.expression));
     }
-    // Sort object keys
-    return JSON.stringify(clone, Object.keys(clone).sort());
+    // We need a stable JSON string for the cache key.
+    // Instead of the broken JSON.stringify(clone, keys) which wipes nested objects,
+    // we manually sort the top-level keys.
+    const sorted = {};
+    Object.keys(clone).sort().forEach(key => {
+        sorted[key] = clone[key];
+    });
+    return JSON.stringify(sorted);
 }
 /**
  * Executes a raw query against the Google Search Console Search Analytics API.
@@ -36,6 +35,9 @@ export async function queryAnalytics(options) {
             return cached;
         }
         if (now - cached.timestamp < CACHE_TTL_MS) {
+            // LRU: Refresh key position
+            analyticsCache.delete(cacheKey);
+            analyticsCache.set(cacheKey, cached);
             return cached.data;
         }
         analyticsCache.delete(cacheKey);
@@ -57,13 +59,16 @@ export async function queryAnalytics(options) {
                 requestBody.startRow = options.startRow;
             }
             if (options.filters && options.filters.length > 0) {
-                requestBody.dimensionFilterGroups = [{
-                        filters: options.filters.map(f => ({
+                // We use separate dimensionFilterGroups for each filter to ensure they are joined by AND.
+                // GSC API joins multiple filters within the same group by OR if they share the same dimension.
+                // By putting them in separate groups, we guarantee strict AND behavior for all filters.
+                requestBody.dimensionFilterGroups = options.filters.map(f => ({
+                    filters: [{
                             dimension: f.dimension,
                             operator: f.operator,
                             expression: f.expression
-                        }))
-                    }];
+                        }]
+                }));
             }
             const res = await client.searchanalytics.query({
                 siteUrl: options.siteUrl,
@@ -356,24 +361,27 @@ export async function detectTrends(siteUrl, options = {}) {
     const limit = options.limit ?? 20;
     // Split the period into two halves
     const midPoint = Math.floor(days / 2);
-    const endDate = new Date();
-    endDate.setDate(endDate.getDate() - DATA_DELAY_DAYS);
-    const midDate = new Date(endDate);
-    midDate.setDate(midDate.getDate() - midPoint);
-    const startDate = new Date(midDate);
-    startDate.setDate(startDate.getDate() - midPoint);
+    // Calculate periods ensuring no overlap
+    const currentEndDate = new Date();
+    currentEndDate.setDate(currentEndDate.getDate() - DATA_DELAY_DAYS);
+    const currentStartDate = new Date(currentEndDate);
+    currentStartDate.setDate(currentStartDate.getDate() - midPoint + 1);
+    const previousEndDate = new Date(currentStartDate);
+    previousEndDate.setDate(previousEndDate.getDate() - 1);
+    const previousStartDate = new Date(previousEndDate);
+    previousStartDate.setDate(previousStartDate.getDate() - midPoint + 1);
     const [currentPeriod, previousPeriod] = await Promise.all([
         queryAnalytics({
             siteUrl,
-            startDate: midDate.toISOString().split('T')[0],
-            endDate: endDate.toISOString().split('T')[0],
+            startDate: currentStartDate.toISOString().split('T')[0],
+            endDate: currentEndDate.toISOString().split('T')[0],
             dimensions: [dimension],
             limit: 5000 // Get enough data to find trends
         }),
         queryAnalytics({
             siteUrl,
-            startDate: startDate.toISOString().split('T')[0],
-            endDate: midDate.toISOString().split('T')[0],
+            startDate: previousStartDate.toISOString().split('T')[0],
+            endDate: previousEndDate.toISOString().split('T')[0],
             dimensions: [dimension],
             limit: 5000
         })

package/dist/index.js

@@ -101,6 +101,22 @@ server.tool("sites_list", "List all verified sites across all authorized account
         return formatError(error);
     }
 });
+server.tool("bing_analytics_trends", "Detect rising or declining trends in Bing query performance", {
+    siteUrl: z.string().describe("The URL of the site"),
+    days: z.number().optional().describe("Number of days to analyze (default 28)"),
+    threshold: z.number().optional().describe("Minimum percentage change (default 10)"),
+    minClicks: z.number().optional().describe("Minimum clicks required (default 100)")
+}, async ({ siteUrl, days, threshold, minClicks }) => {
+    try {
+        const results = await bingAnalytics.detectTrends(siteUrl, { days, threshold, minClicks });
+        return {
+            content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
+        };
+    }
+    catch (error) {
+        return formatError(error);
+    }
+});
 server.tool("sites_add", "Add a new site to Search Console or Bing Webmaster Tools", {
     siteUrl: z.string().describe("The URL of the site to add"),
     engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "search-console-mcp",
-  "version": "1.13.1",
+  "version": "1.13.2",
   "mcpName": "io.github.saurabhsharma2u/search-console-mcp",
   "description": "MCP server for Google Search Console, Bing Webmaster Tools, and Google Analytics 4",
   "type": "module",
@@ -37,7 +37,7 @@
     "@modelcontextprotocol/sdk": "^1.26.0",
     "@napi-rs/keyring": "^1.2.0",
     "cheerio": "^1.2.0",
-    "dotenv": "^17.2.3",
+    "dotenv": "^17.3.1",
     "googleapis": "^171.0.0",
     "node-machine-id": "^1.1.12",
     "open": "^11.0.0",
@@ -52,4 +52,4 @@
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"
   }
-}
+}