search-console-mcp 1.13.0 → 1.13.2

package/README.md

@@ -179,7 +179,7 @@ This MCP server implements a multi-layered security architecture:
 | `analytics_drop_attribution` | **[NEW]** Attribute traffic drops to mobile/desktop or correlate with known Google Algorithm Updates. |
 | `analytics_time_series` | **[NEW]** Advanced time series with rolling averages, seasonality detection, and forecasting. |
 | `analytics_compare_periods` | Compare two date ranges (e.g., WoW, MoM). |
-| `seo_brand_vs_nonbrand` | **[NEW]** Analyze performance split between Brand vs Non-Brand traffic. |
+| `seo_brand_vs_nonbrand` | **[NEW]** Analyze performance split between Brand vs Non-Brand traffic. (Supports Google & Bing). |
 
 ### SEO Opportunities (Opinionated)
 | Tool | Description |
@@ -188,7 +188,7 @@ This MCP server implements a multi-layered security architecture:
 | `seo_striking_distance` | **[NEW]** Find keywords ranking 8-15 (Quickest ROI wins). |
 | `seo_low_ctr_opportunities` | **[NEW]** Find top ranking queries (pos 1-10) with poor CTR. |
 | `seo_cannibalization` | **[Enhanced]** Detect pages competing for the same query with traffic conflict. |
-| `seo_lost_queries` | **[NEW]** Identify queries that lost all traffic in the last 28 days. |
+| `seo_lost_queries` | **[NEW]** Identify queries that lost all traffic in the last 28 days. (Supports Google & Bing). |
 
 ### SEO Primitives (Atoms for Agents)
 These are low-level tools designed to be used by other AI agents to build complex logic.
@@ -226,6 +226,8 @@ These are low-level tools designed to be used by other AI agents to build comple
 | `bing_crawl_issues` | List crawl issues detected by Bing. |
 | `bing_analytics_detect_anomalies` | Detect daily spikes or drops in Bing traffic. |
 | `bing_analytics_time_series` | Advanced time series analysis for Bing. |
+| `bing_seo_lost_queries` | Identify queries that lost significant traffic on Bing. |
+| `bing_brand_analysis` | Analyze performance split between Brand vs Non-Brand traffic on Bing. |
 | `bing_sitemaps_list` / `bing_sitemaps_submit` | Manage sitemaps in Bing. |
 
 ### Google Analytics 4 (GA4)

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/seo-insights.js

@@ -1,4 +1,5 @@
 import { getQueryStats, getQueryPageStats } from './analytics.js';
+import { safeTestBatch } from '../../common/utils/regex.js';
 /**
  * Find "low-hanging fruit" keywords in Bing.
  */
@@ -71,12 +72,12 @@ export async function findLowCTROpportunities(siteUrl, options = {}) {
 /**
  * Detect keyword cannibalization in Bing where multiple pages compete for the same query.
  */
-export async function detectCannibalization(siteUrl, options = {}) {
-    const { minImpressions = 50, limit = 30 } = options;
-    const rows = await getQueryPageStats(siteUrl);
+export async function detectCannibalization(siteUrl, options = {}, rows) {
+    const { minImpressions = 50, limit = 30, startDate, endDate } = options;
+    const stats = rows || await getQueryPageStats(siteUrl, startDate, endDate);
     // Group by query
     const queryMap = new Map();
-    for (const row of rows) {
+    for (const row of stats) {
         if (row.Impressions < minImpressions)
             continue;
         if (!queryMap.has(row.Query)) {
@@ -114,17 +115,105 @@ export async function detectCannibalization(siteUrl, options = {}) {
         .sort((a, b) => (b.totalClicks * b.clickShareConflict) - (a.totalClicks * a.clickShareConflict))
         .slice(0, limit);
 }
+/**
+ * Identify queries that have lost significant visibility or clicks compared to the previous period.
+ */
+export async function findLostQueries(siteUrl, options = {}) {
+    const { days = 28, limit = 50 } = options;
+    const endDate = new Date();
+    endDate.setDate(endDate.getDate() - 2); // Account for data delay
+    const midDate = new Date(endDate);
+    midDate.setDate(midDate.getDate() - days);
+    const startDate = new Date(midDate);
+    startDate.setDate(startDate.getDate() - days);
+    const [currentStats, previousStats] = await Promise.all([
+        getQueryStats(siteUrl, midDate.toISOString().split('T')[0], endDate.toISOString().split('T')[0]),
+        getQueryStats(siteUrl, startDate.toISOString().split('T')[0], midDate.toISOString().split('T')[0])
+    ]);
+    const currentMap = new Map();
+    for (const row of currentStats) {
+        currentMap.set(row.Query, row);
+    }
+    const lostQueries = [];
+    for (const prev of previousStats) {
+        if (prev.Clicks < 5)
+            continue; // Ignore low volume noise
+        const curr = currentMap.get(prev.Query);
+        const currClicks = curr ? curr.Clicks : 0;
+        // Definition of lost: >80% drop or zero
+        if (currClicks === 0 || (currClicks / prev.Clicks) < 0.2) {
+            lostQueries.push({
+                query: prev.Query,
+                previousClicks: prev.Clicks,
+                previousImpressions: prev.Impressions,
+                previousPosition: prev.AvgPosition,
+                currentClicks: currClicks,
+                currentImpressions: curr ? curr.Impressions : 0,
+                currentPosition: curr ? curr.AvgPosition : 0,
+                lostClicks: prev.Clicks - currClicks
+            });
+        }
+    }
+    return lostQueries
+        .sort((a, b) => b.lostClicks - a.lostClicks)
+        .slice(0, limit);
+}
+/**
+ * Segment search performance into Brand and Non-Brand categories.
+ */
+export async function analyzeBrandVsNonBrand(siteUrl, brandRegexString, options = {}) {
+    const { days = 28 } = options;
+    const endDate = new Date();
+    endDate.setDate(endDate.getDate() - 2);
+    const startDate = new Date(endDate);
+    startDate.setDate(startDate.getDate() - days);
+    const rows = await getQueryStats(siteUrl, startDate.toISOString().split('T')[0], endDate.toISOString().split('T')[0]);
+    const queries = rows.map(r => r.Query);
+    const isBrandResults = safeTestBatch(brandRegexString, 'i', queries);
+    const brandStats = { clicks: 0, impressions: 0, weightedPos: 0, queryCount: 0 };
+    const nonBrandStats = { clicks: 0, impressions: 0, weightedPos: 0, queryCount: 0 };
+    rows.forEach((row, index) => {
+        const isBrand = isBrandResults[index];
+        const stats = isBrand ? brandStats : nonBrandStats;
+        stats.clicks += row.Clicks;
+        stats.impressions += row.Impressions;
+        stats.weightedPos += row.AvgPosition * row.Impressions;
+        stats.queryCount++;
+    });
+    const calc = (stats, segment) => ({
+        segment,
+        clicks: stats.clicks,
+        impressions: stats.impressions,
+        ctr: stats.impressions > 0 ? stats.clicks / stats.impressions : 0,
+        position: stats.impressions > 0 ? stats.weightedPos / stats.impressions : 0,
+        queryCount: stats.queryCount
+    });
+    return [
+        calc(brandStats, 'Brand'),
+        calc(nonBrandStats, 'Non-Brand')
+    ];
+}
 /**
  * Generate prioritized Bing SEO recommendations.
  */
-export async function generateRecommendations(siteUrl) {
+export async function generateRecommendations(siteUrl, options = {}) {
+    const { days = 28 } = options;
     const insights = [];
-    const queryStatsPromise = getQueryStats(siteUrl);
+    const endDate = new Date();
+    endDate.setDate(endDate.getDate() - 2);
+    const startDate = new Date(endDate);
+    startDate.setDate(startDate.getDate() - days);
+    const sDate = startDate.toISOString().split('T')[0];
+    const eDate = endDate.toISOString().split('T')[0];
+    const [queryStats, queryPageStats] = await Promise.all([
+        getQueryStats(siteUrl, sDate, eDate),
+        getQueryPageStats(siteUrl, sDate, eDate)
+    ]);
     const [lowHangingFruit, strikingDistance, lowCTR, cannibalization] = await Promise.all([
-        queryStatsPromise.then(stats => findLowHangingFruit(siteUrl, { limit: 10, queryStats: stats })),
-        queryStatsPromise.then(stats => findStrikingDistance(siteUrl, { limit: 10, queryStats: stats })),
-        queryStatsPromise.then(stats => findLowCTROpportunities(siteUrl, { limit: 10, queryStats: stats })),
-        detectCannibalization(siteUrl, { limit: 10 })
+        findLowHangingFruit(siteUrl, { limit: 10, queryStats: queryStats }),
+        findStrikingDistance(siteUrl, { limit: 10, queryStats: queryStats }),
+        findLowCTROpportunities(siteUrl, { limit: 10, queryStats: queryStats }),
+        detectCannibalization(siteUrl, { limit: 10, startDate: sDate, endDate: eDate }, queryPageStats)
     ]);
     if (lowHangingFruit.length > 0) {
         const totalPotential = lowHangingFruit.reduce((sum, l) => sum + l.potentialClicks, 0);

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/common/auth/config.js

@@ -7,6 +7,10 @@ const { machineIdSync } = nodeMachineId;
 const CONFIG_PATH = join(homedir(), '.search-console-mcp-config.enc');
 const LEGACY_TOKEN_PATH = join(homedir(), '.search-console-mcp-tokens.enc');
 const ENCRYPTION_ALGORITHM = 'aes-256-gcm';
+let cachedConfig = null;
+export function resetConfigCache() {
+    cachedConfig = null;
+}
 function getEncryptionKey() {
     const mId = machineIdSync();
     const salt = process.env.USER || 'sc-mcp-salt';
@@ -36,6 +40,9 @@ function decrypt(data) {
  * Load the unified configuration, including lazy migration from legacy Google tokens.
  */
 export async function loadConfig() {
+    if (cachedConfig) {
+        return cachedConfig;
+    }
     let config = { accounts: {} };
     // 1. Try to load from new unified config
     if (existsSync(CONFIG_PATH)) {
@@ -125,12 +132,14 @@ export async function loadConfig() {
             };
         }
     }
+    cachedConfig = config;
     return config;
 }
 export async function saveConfig(config) {
     try {
         const encrypted = encrypt(JSON.stringify(config));
         writeFileSync(CONFIG_PATH, encrypted, { mode: 0o600 });
+        cachedConfig = config;
     }
     catch (e) {
         console.error('Failed to save config:', e.message);

package/dist/common/utils/csv.js

@@ -0,0 +1,27 @@
+/**
+ * Convert an array of flat JSON objects to a CSV string.
+ * Automatically handles escaping of double quotes and commas.
+ */
+export function jsonToCsv(data) {
+    if (!data || data.length === 0) {
+        return "";
+    }
+    // Get headers from the first object
+    const headers = Object.keys(data[0]);
+    const csvRows = [headers.join(',')];
+    for (const row of data) {
+        const values = headers.map(header => {
+            const val = row[header];
+            const stringVal = val === undefined || val === null ? '' : String(val);
+            // Escape double quotes by doubling them
+            const escaped = stringVal.replace(/"/g, '""');
+            // Wrap in quotes if it contains comma, quote or newline
+            if (escaped.includes(',') || escaped.includes('"') || escaped.includes('\n')) {
+                return `"${escaped}"`;
+            }
+            return escaped;
+        });
+        csvRows.push(values.join(','));
+    }
+    return csvRows.join('\n');
+}

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

@@ -44,6 +44,7 @@ import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import { getStartedHandler, getStartedToolName, getStartedToolDescription, getStartedToolSchema } from "./common/tools/get-started.js";
 import { registerPrompts } from "./prompts/index.js";
+import { jsonToCsv } from "./common/utils/csv.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Load version from package.json
@@ -100,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)")
@@ -229,10 +246,29 @@ server.tool("analytics_query", "Query search analytics data with optional pagina
         dimension: z.string(),
         operator: z.string(),
         expression: z.string()
-    })).optional().describe("Filters (dimension: query/page/country/device, operator: equals/contains/notContains/includingRegex/excludingRegex)")
+    })).optional().describe("Filters (dimension: query/page/country/device, operator: equals/contains/notContains/includingRegex/excludingRegex)"),
+    format: z.enum(["json", "csv"]).optional().describe("Output format (default: json)")
 }, async (args) => {
     try {
         const result = await analytics.queryAnalytics(args);
+        if (args.format === 'csv') {
+            const flatData = result.map(row => {
+                const newRow = { ...row };
+                if (row.keys && Array.isArray(row.keys)) {
+                    row.keys.forEach((keyVal, idx) => {
+                        const dimName = args.dimensions && args.dimensions[idx]
+                            ? args.dimensions[idx]
+                            : `dimension_${idx + 1}`;
+                        newRow[dimName] = keyVal;
+                    });
+                    delete newRow.keys;
+                }
+                return newRow;
+            });
+            return {
+                content: [{ type: "text", text: jsonToCsv(flatData) }]
+            };
+        }
         return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
         };
@@ -514,10 +550,13 @@ server.tool("pagespeed_core_web_vitals", "Get Core Web Vitals for both mobile an
 // SEO Insights Tools
 server.tool("seo_recommendations", "Generate SEO recommendations based on site performance data", {
     siteUrl: z.string().describe("The site URL (e.g., https://example.com)"),
-    days: z.number().optional().describe("Number of days to analyze (default: 28)")
-}, async ({ siteUrl, days }) => {
+    days: z.number().optional().describe("Number of days to analyze (default: 28)"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")
+}, async ({ siteUrl, days, engine = "google" }) => {
     try {
-        const result = await seoInsights.generateRecommendations(siteUrl, { days });
+        const result = engine === "google"
+            ? await seoInsights.generateRecommendations(siteUrl, { days })
+            : await bingSeoInsights.generateRecommendations(siteUrl, { days });
         return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
         };
@@ -604,10 +643,13 @@ server.tool("seo_striking_distance", "Find keywords ranking in positions 8-15. T
 server.tool("seo_lost_queries", "Identify queries that lost all traffic (or dropped >80%) compared to the previous period.", {
     siteUrl: z.string().describe("The site URL"),
     days: z.number().optional().describe("Number of days to compare (default: 28)"),
-    limit: z.number().optional().describe("Max results to return (default: 50)")
-}, async ({ siteUrl, days, limit }) => {
+    limit: z.number().optional().describe("Max results to return (default: 50)"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")
+}, async ({ siteUrl, days, limit, engine = "google" }) => {
     try {
-        const result = await seoInsights.findLostQueries(siteUrl, { days, limit });
+        const result = engine === "google"
+            ? await seoInsights.findLostQueries(siteUrl, { days, limit })
+            : await bingSeoInsights.findLostQueries(siteUrl, { days, limit });
         return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
         };
@@ -619,10 +661,13 @@ server.tool("seo_lost_queries", "Identify queries that lost all traffic (or drop
 server.tool("seo_brand_vs_nonbrand", "Analyze performance split between Brand and Non-Brand queries using a regex.", {
     siteUrl: z.string().describe("The site URL"),
     brandRegex: z.string().describe("Regex to match brand keywords (e.g. 'acme|acme corp')"),
-    days: z.number().optional().describe("Number of days to analyze (default: 28)")
-}, async ({ siteUrl, brandRegex, days }) => {
+    days: z.number().optional().describe("Number of days to analyze (default: 28)"),
+    engine: z.enum(["google", "bing"]).optional().describe("The search engine (default: google)")
+}, async ({ siteUrl, brandRegex, days, engine = "google" }) => {
     try {
-        const result = await seoInsights.analyzeBrandVsNonBrand(siteUrl, brandRegex, { days });
+        const result = engine === "google"
+            ? await seoInsights.analyzeBrandVsNonBrand(siteUrl, brandRegex, { days })
+            : await bingSeoInsights.analyzeBrandVsNonBrand(siteUrl, brandRegex, { days });
         return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
         };
@@ -850,10 +895,22 @@ server.tool("bing_sitemaps_delete", "Remove a sitemap from Bing Webmaster Tools"
     }
 });
 server.tool("bing_analytics_query", "Get query performance stats from Bing Webmaster Tools (Top Queries)", {
-    siteUrl: z.string().describe("The URL of the site")
-}, async ({ siteUrl }) => {
+    siteUrl: z.string().describe("The URL of the site"),
+    startDate: z.string().optional().describe("Start date (YYYY-MM-DD)"),
+    endDate: z.string().optional().describe("End date (YYYY-MM-DD)"),
+    limit: z.number().optional().describe("Max rows to return (default: 1000)"),
+    format: z.enum(["json", "csv"]).optional().describe("Output format (default: json)")
+}, async ({ siteUrl, startDate, endDate, limit, format }) => {
     try {
-        const results = await bingAnalytics.getQueryStats(siteUrl);
+        let results = await bingAnalytics.getQueryStats(siteUrl, startDate, endDate);
+        if (limit) {
+            results = results.slice(0, limit);
+        }
+        if (format === 'csv') {
+            return {
+                content: [{ type: "text", text: jsonToCsv(results) }]
+            };
+        }
         return {
             content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
         };
@@ -1226,10 +1283,16 @@ server.tool("analytics_page_performance", "Get detailed page performance metrics
     startDate: z.string().describe("Start date (YYYY-MM-DD)"),
     endDate: z.string().describe("End date (YYYY-MM-DD)"),
     pagePath: z.string().optional().describe("Filter by specific page path"),
-    limit: z.number().optional().describe("Max rows (default 50)")
-}, async ({ propertyId, accountId, startDate, endDate, pagePath, limit }) => {
+    limit: z.number().optional().describe("Max rows (default 50)"),
+    format: z.enum(["json", "csv"]).optional().describe("Output format (default: json)")
+}, async ({ propertyId, accountId, startDate, endDate, pagePath, limit, format }) => {
     try {
         const result = await ga4Analytics.getPagePerformance(propertyId, startDate, endDate, pagePath, limit, accountId);
+        if (format === 'csv') {
+            return {
+                content: [{ type: "text", text: jsonToCsv(result) }]
+            };
+        }
         return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "search-console-mcp",
-  "version": "1.13.0",
+  "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"
   }
-}
+}