@gscdump/cli 0.1.3 → 0.2.0

package/dist/index.mjs

@@ -1,22 +1,19 @@
 #!/usr/bin/env node
-import { t as eq } from "./_chunks/libs/drizzle-orm.mjs";
 import "node:module";
 import process from "node:process";
 import { defineCommand, runMain } from "citty";
-import path from "node:path";
-import { batchInspectUrls, batchRequestIndexingForPaths, createGscDb, getIndexingStats, getLastSyncedDate, getSiteByProperty, setupSchema, sitePathDateAnalytics, syncCountries, syncDevices, syncKeywordPaths, syncKeywords, syncPages, syncSites, updateLastSynced } from "@gscdump/db";
-import { createProvider, daysAgo, fetchCannibalizationAnalysis, fetchDecayAnalysis, fetchMoversAnalysis, fetchOpportunityAnalysis, fetchStrikingDistanceAnalysis, fetchZeroClickAnalysis } from "@gscdump/query";
-import dayjs from "dayjs";
-import betterSqlite3 from "db0/connectors/better-sqlite3";
 import fs from "node:fs/promises";
 import { createServer } from "node:http";
-import { cancel, confirm, isCancel, multiselect, select, text } from "@clack/prompts";
+import path from "node:path";
+import { cancel, isCancel, multiselect, select, text } from "@clack/prompts";
 import { OAuth2Client } from "google-auth-library";
 import os from "node:os";
 import { consola } from "consola";
-import { deleteSitemap, fetchSitemap, fetchSitemaps, fetchSites, formatErrorForCli, googleSearchConsole, submitSitemap } from "gscdump";
-import { createGscMcpServer } from "@gscdump/mcp/server";
+import { batchInspectUrls, batchRequestIndexing, deleteSitemap, fetchSitemap, fetchSitemaps, fetchSites, fetchSitesWithSitemaps, formatErrorForCli, getIndexingMetadata, googleSearchConsole, inspectUrl, requestIndexing, submitSitemap } from "gscdump";
+import { between, country, date, device, gsc, page, query, searchAppearance } from "gscdump/query";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
 
 //#region rolldown:runtime
 var __defProp = Object.defineProperty;
@@ -103,22 +100,6 @@ function progressBar(current, total, label, width = 30) {
 function clearLine() {
 	process.stdout.write("\r\x1B[K");
 }
-function parsePeriod(periodStr) {
-	const match = periodStr.match(/^(\d+)([dmy])$/i);
-	if (!match) return null;
-	const amount = Number.parseInt(match[1], 10);
-	const unit = {
-		d: "days",
-		m: "months",
-		y: "years"
-	}[match[2].toLowerCase()];
-	if (!unit || amount <= 0) return null;
-	if (amount > 450 && unit === "days") return null;
-	return {
-		amount,
-		unit
-	};
-}
 function toCSV(data, columns) {
 	return [columns.join(","), ...data.map((row) => columns.map((col) => {
 		const val = row[col];
@@ -421,227 +402,6 @@ async function getAuth(opts = {}) {
 	return authenticate(await getAuthCredentials(interactive), interactive);
 }
 
-//#endregion
-//#region src/commands/analyze.ts
-function getProviderForSource$2(auth, db, source) {
-	if (source === "api") return createProvider({ auth });
-	if (source === "db") {
-		if (!db) throw new Error("Database required for db source");
-		return createProvider({ db });
-	}
-	return db ? createProvider({
-		auth,
-		db
-	}) : createProvider({ auth });
-}
-const ANALYSIS_TYPES = [
-	"striking-distance",
-	"opportunity",
-	"movers",
-	"decay",
-	"cannibalization",
-	"zero-click"
-];
-const analyzeCommand = defineCommand({
-	meta: {
-		name: "analyze",
-		description: "Run SEO analysis on site data"
-	},
-	args: {
-		type: {
-			type: "positional",
-			required: true,
-			description: `Analysis type: ${ANALYSIS_TYPES.join(", ")}`
-		},
-		site: {
-			type: "string",
-			alias: "s",
-			description: "Site URL (e.g., sc-domain:example.com)"
-		},
-		period: {
-			type: "string",
-			alias: "p",
-			default: "28d",
-			description: "Period to analyze (e.g., 7d, 28d, 3m)"
-		},
-		limit: {
-			type: "string",
-			alias: "l",
-			default: "20",
-			description: "Number of results to show"
-		},
-		json: {
-			type: "boolean",
-			default: false,
-			description: "Output as JSON"
-		},
-		db: {
-			type: "string",
-			alias: "d",
-			description: "Path to SQLite database"
-		},
-		source: {
-			type: "string",
-			default: "auto",
-			description: "Data source: api, db, auto"
-		},
-		minPosition: {
-			type: "string",
-			description: "Minimum position (striking-distance)"
-		},
-		maxPosition: {
-			type: "string",
-			description: "Maximum position (striking-distance, zero-click)"
-		},
-		minImpressions: {
-			type: "string",
-			description: "Minimum impressions"
-		},
-		minClicks: {
-			type: "string",
-			description: "Minimum clicks (decay)"
-		},
-		threshold: {
-			type: "string",
-			description: "Threshold percentage 0-1 (decay, movers)"
-		}
-	},
-	async run({ args }) {
-		const analysisType = args.type;
-		if (!ANALYSIS_TYPES.includes(analysisType)) {
-			logger.error(`Unknown analysis type: ${analysisType}`);
-			logger.info(`Available: ${ANALYSIS_TYPES.join(", ")}`);
-			process.exit(1);
-		}
-		const config = await loadConfig();
-		const siteArg = args.site || config.defaultSite;
-		if (!siteArg) {
-			logger.error("Site required. Use --site or set defaultSite in config.");
-			process.exit(1);
-		}
-		const dbPath = args.db || config.defaultDb;
-		const auth = await getAuth({
-			interactive: false,
-			config
-		});
-		const period = parsePeriod(args.period);
-		if (!period) {
-			logger.error(`Invalid period: ${args.period}`);
-			process.exit(1);
-		}
-		const endDate = dayjs().subtract(3, "day");
-		const startDate = endDate.subtract(period.amount, period.unit);
-		const prevEndDate = startDate.subtract(1, "day");
-		const prevStartDate = prevEndDate.subtract(period.amount, period.unit);
-		const range = {
-			period: {
-				start: startDate.format("YYYY-MM-DD"),
-				end: endDate.format("YYYY-MM-DD")
-			},
-			prevPeriod: {
-				start: prevStartDate.format("YYYY-MM-DD"),
-				end: prevEndDate.format("YYYY-MM-DD")
-			}
-		};
-		const provider = getProviderForSource$2(auth, dbPath ? createGscDb(betterSqlite3({ name: path.resolve(dbPath) })).db : null, args.source);
-		const limit = Number.parseInt(args.limit, 10) || 20;
-		if (!args.json) {
-			console.log();
-			console.log(`  \x1B[1m${siteArg}\x1B[0m`);
-			console.log(`  \x1B[90mSource:   ${provider.source}\x1B[0m`);
-			console.log(`  \x1B[90mPeriod:   ${range.period.start} → ${range.period.end}\x1B[0m`);
-			console.log(`  \x1B[90mAnalysis: ${analysisType}\x1B[0m`);
-			console.log();
-		}
-		let results;
-		switch (analysisType) {
-			case "striking-distance":
-				results = await fetchStrikingDistanceAnalysis(provider, siteArg, range, {
-					minPosition: args.minPosition ? Number(args.minPosition) : void 0,
-					maxPosition: args.maxPosition ? Number(args.maxPosition) : void 0,
-					minImpressions: args.minImpressions ? Number(args.minImpressions) : void 0
-				}).catch(gscErrorHandler);
-				break;
-			case "opportunity":
-				results = await fetchOpportunityAnalysis(provider, siteArg, range, { minImpressions: args.minImpressions ? Number(args.minImpressions) : void 0 }).catch(gscErrorHandler);
-				break;
-			case "movers":
-				results = await fetchMoversAnalysis(provider, siteArg, range, {
-					changeThreshold: args.threshold ? Number(args.threshold) : void 0,
-					minImpressions: args.minImpressions ? Number(args.minImpressions) : void 0
-				}).catch(gscErrorHandler);
-				break;
-			case "decay":
-				results = await fetchDecayAnalysis(provider, siteArg, range, {
-					minPreviousClicks: args.minClicks ? Number(args.minClicks) : void 0,
-					threshold: args.threshold ? Number(args.threshold) : void 0
-				}).catch(gscErrorHandler);
-				break;
-			case "cannibalization":
-				results = await fetchCannibalizationAnalysis(provider, siteArg, range, { minImpressions: args.minImpressions ? Number(args.minImpressions) : void 0 }).catch(gscErrorHandler);
-				break;
-			case "zero-click":
-				results = await fetchZeroClickAnalysis(provider, siteArg, range, {
-					minImpressions: args.minImpressions ? Number(args.minImpressions) : void 0,
-					maxPosition: args.maxPosition ? Number(args.maxPosition) : void 0
-				}).catch(gscErrorHandler);
-				break;
-		}
-		if (args.json) {
-			console.log(JSON.stringify({
-				site: siteArg,
-				source: provider.source,
-				analysis: analysisType,
-				range,
-				results
-			}, null, 2));
-			return;
-		}
-		const arr = Array.isArray(results) ? results : [];
-		const display = arr.slice(0, limit);
-		if (display.length === 0) {
-			logger.warn("No results found");
-			return;
-		}
-		console.log(`  \x1B[1mResults\x1B[0m \x1B[90m(${arr.length} total, showing ${display.length})\x1B[0m`);
-		for (const item of display) formatResultItem(analysisType, item);
-		console.log();
-		logger.success("Analysis complete");
-	}
-});
-function formatResultItem(type, item) {
-	const keyword = item.keyword || item.query || "";
-	const page = item.page || "";
-	switch (type) {
-		case "striking-distance":
-			console.log(`    ${keyword.slice(0, 40).padEnd(40)} pos ${String(item.position || 0).padStart(5)} ${formatNumber$1(item.impressions)} impr ${formatNumber$1(item.potentialClicks)} potential`);
-			break;
-		case "opportunity":
-			console.log(`    ${keyword.slice(0, 40).padEnd(40)} score ${String((item.score || 0).toFixed(1)).padStart(6)} ${formatNumber$1(item.impressions)} impr`);
-			break;
-		case "movers":
-			console.log(`    ${keyword.slice(0, 40).padEnd(40)} ${formatChange(item.clicksChange)} clicks ${formatChange(item.positionChange)} pos`);
-			break;
-		case "decay":
-			console.log(`    ${page.replace(/^https?:\/\/[^/]+/, "").slice(0, 50).padEnd(50)} -${formatNumber$1(item.lostClicks)} clicks (${((item.declinePercent || 0) * 100).toFixed(0)}% decline)`);
-			break;
-		case "cannibalization":
-			console.log(`    ${keyword.slice(0, 40).padEnd(40)} ${item.pageCount} pages ${formatNumber$1(item.clicks)} clicks spread ${item.positionSpread}`);
-			break;
-		case "zero-click":
-			console.log(`    ${keyword.slice(0, 40).padEnd(40)} pos ${String(item.position || 0).padStart(5)} ${formatNumber$1(item.impressions)} impr ${((item.ctr || 0) * 100).toFixed(2)}% ctr`);
-			break;
-	}
-}
-function formatNumber$1(val) {
-	if (val === void 0 || val === null) return "-";
-	return val.toLocaleString();
-}
-function formatChange(val) {
-	if (val === void 0 || val === null || !Number.isFinite(val)) return "\x1B[90m-\x1B[0m";
-	return `${val > 0 ? "\x1B[32m" : val < 0 ? "\x1B[31m" : "\x1B[90m"}${val > 0 ? "+" : ""}${val.toFixed(1)}%\x1B[0m`;
-}
-
 //#endregion
 //#region src/commands/auth.ts
 const statusCommand = defineCommand({
@@ -720,255 +480,6 @@ const authCommand = defineCommand({
 	}
 });
 
-//#endregion
-//#region src/commands/compare.ts
-function getProviderForSource$1(auth, db, source) {
-	if (source === "api") return createProvider({ auth });
-	if (source === "db") {
-		if (!db) throw new Error("Database required for db source");
-		return createProvider({ db });
-	}
-	return db ? createProvider({
-		auth,
-		db
-	}) : createProvider({ auth });
-}
-const SEARCH_TYPES = [
-	"web",
-	"image",
-	"video",
-	"news",
-	"discover",
-	"googleNews"
-];
-function formatPercent(val) {
-	if (val === void 0 || val === null || !Number.isFinite(val)) return "\x1B[90m-\x1B[0m";
-	return `${val > 0 ? "\x1B[32m" : val < 0 ? "\x1B[31m" : "\x1B[90m"}${val > 0 ? "+" : ""}${val.toFixed(1)}%\x1B[0m`;
-}
-function formatNumber(val) {
-	if (val === void 0 || val === null) return "-";
-	return val.toLocaleString();
-}
-const compareCommand = defineCommand({
-	meta: {
-		name: "compare",
-		description: "Compare site performance across periods"
-	},
-	args: {
-		site: {
-			type: "string",
-			alias: "s",
-			description: "Site URL (e.g., sc-domain:example.com)"
-		},
-		period: {
-			type: "string",
-			alias: "p",
-			default: "7d",
-			description: "Period to compare (e.g., 7d, 30d, 3m)"
-		},
-		from: {
-			type: "string",
-			description: "Custom start date (YYYY-MM-DD)"
-		},
-		to: {
-			type: "string",
-			description: "Custom end date (YYYY-MM-DD)"
-		},
-		vs: {
-			type: "string",
-			description: "Comparison period start date (YYYY-MM-DD)"
-		},
-		json: {
-			type: "boolean",
-			default: false,
-			description: "Output as JSON"
-		},
-		type: {
-			type: "string",
-			alias: "t",
-			default: "summary",
-			description: "Output type: summary, pages, keywords"
-		},
-		limit: {
-			type: "string",
-			alias: "l",
-			default: "10",
-			description: "Number of items to show (for pages/keywords)"
-		},
-		fresh: {
-			type: "boolean",
-			default: false,
-			description: "Include fresh/unfinalized data (last 3 days)"
-		},
-		searchType: {
-			type: "string",
-			default: "web",
-			description: "Search type: web, image, video, news, discover, googleNews"
-		},
-		db: {
-			type: "string",
-			alias: "d",
-			description: "Path to SQLite database for local queries"
-		},
-		source: {
-			type: "string",
-			default: "auto",
-			description: "Data source: api, db, auto"
-		},
-		quiet: {
-			type: "boolean",
-			alias: "q",
-			default: false,
-			description: "Suppress output"
-		}
-	},
-	async run({ args }) {
-		const config = await loadConfig();
-		const siteArg = args.site || config.defaultSite;
-		if (!siteArg) {
-			logger.error("Site required. Use --site or set defaultSite in config.");
-			process.exit(1);
-		}
-		const dbPath = args.db || config.defaultDb;
-		const periodArg = args.period === "7d" && config.defaultPeriod ? config.defaultPeriod : args.period;
-		const auth = await getAuth({
-			interactive: false,
-			config
-		});
-		let range;
-		if (args.from && args.to) {
-			const start = dayjs(args.from);
-			const end = dayjs(args.to);
-			if (!start.isValid() || !end.isValid()) {
-				logger.error("Invalid date format. Use YYYY-MM-DD");
-				process.exit(1);
-			}
-			const periodDays = end.diff(start, "day");
-			let prevStart;
-			let prevEnd;
-			if (args.vs) {
-				prevStart = dayjs(args.vs);
-				if (!prevStart.isValid()) {
-					logger.error("Invalid --vs date format. Use YYYY-MM-DD");
-					process.exit(1);
-				}
-				prevEnd = prevStart.add(periodDays, "day");
-			} else {
-				prevEnd = start.subtract(1, "day");
-				prevStart = prevEnd.subtract(periodDays, "day");
-			}
-			range = {
-				period: {
-					start: start.format("YYYY-MM-DD"),
-					end: end.format("YYYY-MM-DD")
-				},
-				prevPeriod: {
-					start: prevStart.format("YYYY-MM-DD"),
-					end: prevEnd.format("YYYY-MM-DD")
-				}
-			};
-		} else {
-			const period = parsePeriod(periodArg);
-			if (!period) {
-				logger.error(`Invalid period: ${periodArg}`);
-				process.exit(1);
-			}
-			const daysOffset = args.fresh ? 1 : 3;
-			const endDate = dayjs().subtract(daysOffset, "day");
-			const startDate = endDate.subtract(period.amount, period.unit);
-			const prevEndDate = startDate.subtract(1, "day");
-			const prevStartDate = prevEndDate.subtract(period.amount, period.unit);
-			range = {
-				period: {
-					start: startDate.format("YYYY-MM-DD"),
-					end: endDate.format("YYYY-MM-DD")
-				},
-				prevPeriod: {
-					start: prevStartDate.format("YYYY-MM-DD"),
-					end: prevEndDate.format("YYYY-MM-DD")
-				}
-			};
-		}
-		const searchType = SEARCH_TYPES.includes(args.searchType) ? args.searchType : "web";
-		const effectiveSource = searchType !== "web" ? "api" : args.source || "auto";
-		if (searchType !== "web" && args.source === "db") logger.warn(`Search type '${searchType}' requires API. Ignoring --source db.`);
-		const provider = getProviderForSource$1(auth, dbPath ? createGscDb(betterSqlite3({ name: path.resolve(dbPath) })).db : null, effectiveSource);
-		if (args.json) {
-			const [dates, pages, keywords] = await Promise.all([
-				provider.getDatesWithComparison(siteArg, range),
-				provider.getPagesWithComparison(siteArg, range),
-				provider.getKeywordsWithComparison(siteArg, range)
-			]).catch(gscErrorHandler);
-			console.log(JSON.stringify({
-				site: siteArg,
-				source: provider.source,
-				range,
-				dates,
-				pages,
-				keywords
-			}, null, 2));
-			return;
-		}
-		if (args.quiet) return;
-		console.log();
-		console.log(`  \x1B[1m${siteArg}\x1B[0m`);
-		console.log(`  \x1B[90mSource:   ${provider.source}\x1B[0m`);
-		console.log(`  \x1B[90mCurrent:  ${range.period.start} → ${range.period.end}\x1B[0m`);
-		console.log(`  \x1B[90mPrevious: ${range.prevPeriod?.start} → ${range.prevPeriod?.end}\x1B[0m`);
-		console.log();
-		if (args.type === "summary" || args.type === "all") {
-			const dates = await provider.getDatesWithComparison(siteArg, range).catch(gscErrorHandler);
-			console.log("  \x1B[1mSummary\x1B[0m");
-			console.log(`  ┌─────────────┬──────────────┬──────────────┬─────────────┐`);
-			console.log(`  │             │ \x1B[1mCurrent\x1B[0m      │ \x1B[1mPrevious\x1B[0m     │ \x1B[1mChange\x1B[0m      │`);
-			console.log(`  ├─────────────┼──────────────┼──────────────┼─────────────┤`);
-			console.log(`  │ Clicks      │ ${formatNumber(dates.metadata.totals.current.clicks).padStart(12)} │ ${formatNumber(dates.metadata.totals.previous.clicks).padStart(12)} │ ${formatPercent(dates.metadata.totals.clicksPercent).padStart(19)} │`);
-			console.log(`  │ Impressions │ ${formatNumber(dates.metadata.totals.current.impressions).padStart(12)} │ ${formatNumber(dates.metadata.totals.previous.impressions).padStart(12)} │ ${formatPercent(dates.metadata.totals.impressionsPercent).padStart(19)} │`);
-			console.log(`  │ CTR         │ ${(dates.metadata.totals.current.ctr * 100).toFixed(2).padStart(10)}% │ ${(dates.metadata.totals.previous.ctr * 100).toFixed(2).padStart(10)}% │ ${formatPercent(dates.metadata.totals.ctrPercent).padStart(19)} │`);
-			console.log(`  │ Position    │ ${dates.metadata.totals.current.position.toFixed(1).padStart(12)} │ ${dates.metadata.totals.previous.position.toFixed(1).padStart(12)} │ ${formatPercent(dates.metadata.totals.positionPercent).padStart(19)} │`);
-			console.log(`  └─────────────┴──────────────┴──────────────┴─────────────┘`);
-			console.log();
-		}
-		const limit = Number.parseInt(args.limit, 10) || 10;
-		if (args.type === "pages" || args.type === "all") {
-			const pages = await provider.getPagesWithComparison(siteArg, range).catch(gscErrorHandler);
-			const topPages = pages.current.slice(0, limit);
-			const lostPages = pages.previous.filter((p) => p.lost).slice(0, 5);
-			console.log(`  \x1B[1mTop Pages\x1B[0m \x1B[90m(${pages.current.length} total)\x1B[0m`);
-			for (const p of topPages) {
-				const pagePath = p.page.replace(/^https?:\/\/[^/]+/, "") || "/";
-				console.log(`    ${pagePath.slice(0, 50).padEnd(50)} ${formatNumber(p.clicks).padStart(8)} clicks ${formatPercent(p.clicksPercent)}`);
-			}
-			if (lostPages.length > 0) {
-				console.log();
-				console.log(`  \x1B[1mLost Pages\x1B[0m \x1B[90m(had traffic in previous period)\x1B[0m`);
-				for (const p of lostPages) {
-					const pagePath = p.page.replace(/^https?:\/\/[^/]+/, "") || "/";
-					console.log(`    \x1B[31m${pagePath.slice(0, 50).padEnd(50)}\x1B[0m ${formatNumber(p.prevClicks).padStart(8)} prev clicks`);
-				}
-			}
-			console.log();
-		}
-		if (args.type === "keywords" || args.type === "all") {
-			const keywords = await provider.getKeywordsWithComparison(siteArg, range).catch(gscErrorHandler);
-			const topKeywords = keywords.current.slice(0, limit);
-			const lostKeywords = keywords.previous.filter((k) => k.lost).slice(0, 5);
-			console.log(`  \x1B[1mTop Keywords\x1B[0m \x1B[90m(${keywords.current.length} total)\x1B[0m`);
-			for (const k of topKeywords) {
-				const posChange = k.prevPosition ? formatPercent(-((k.position || 0) - k.prevPosition) / k.prevPosition * 100) : "";
-				console.log(`    ${k.keyword.slice(0, 40).padEnd(40)} pos ${(k.position || 0).toFixed(1).padStart(5)} ${posChange} ${formatNumber(k.clicks).padStart(6)} clicks`);
-			}
-			if (lostKeywords.length > 0) {
-				console.log();
-				console.log(`  \x1B[1mLost Keywords\x1B[0m \x1B[90m(had traffic in previous period)\x1B[0m`);
-				for (const k of lostKeywords) console.log(`    \x1B[31m${k.keyword.slice(0, 40).padEnd(40)}\x1B[0m pos ${(k.prevPosition || 0).toFixed(1).padStart(5)} ${formatNumber(k.prevClicks).padStart(6)} prev clicks`);
-			}
-			console.log();
-		}
-		logger.success("Comparison complete");
-	}
-});
-
 //#endregion
 //#region src/commands/config.ts
 const showCommand = defineCommand({
@@ -1064,747 +575,190 @@ const configCommand = defineCommand({
 
 //#endregion
 //#region src/commands/dump.ts
-/**
-* Maps CLI source option to provider options
-* - 'api': API only (no db)
-* - 'db': DB only (no auth, errors if data missing)
-* - 'auto': Hybrid (both auth and db, syncs on cache miss)
-*/
-function getProviderForSource(auth, db, source) {
-	if (source === "api") return createProvider({ auth });
-	if (source === "db") {
-		if (!db) throw new Error("Database required for db source");
-		return createProvider({ db });
-	}
-	return db ? createProvider({
-		auth,
-		db
-	}) : createProvider({ auth });
-}
 const DUMP_DATA_TYPES = [
 	"pages",
 	"keywords",
 	"countries",
 	"devices"
 ];
-async function getSites(client) {
-	return (await fetchSites(client)).filter((site) => site.siteUrl && site.permissionLevel !== "siteUnverifiedUser").map((site) => site.siteUrl);
-}
-async function runDump(provider, selectedSites, dataTypes, period, format, outputFile, options = {}) {
-	const daysOffset = options.fresh ? 1 : 3;
-	const endDate = dayjs().subtract(daysOffset, "days").format("YYYY-MM-DD");
-	const startDate = dayjs().subtract(period.amount, period.unit).subtract(daysOffset, "days").format("YYYY-MM-DD");
-	const range = {
-		period: {
-			start: startDate,
-			end: endDate
-		},
-		prevPeriod: {
-			start: dayjs(startDate).subtract(period.amount, period.unit).format("YYYY-MM-DD"),
-			end: dayjs(endDate).subtract(period.amount, period.unit).format("YYYY-MM-DD")
-		}
-	};
-	for (const siteUrl of selectedSites) {
-		const siteName = siteUrl.replace(/https?:\/\//, "").replace(/\/$/, "");
-		const output = {
-			siteUrl,
-			source: provider.source,
-			dateRange: {
-				startDate,
-				endDate
-			},
-			period: {
-				amount: period.amount,
-				unit: period.unit
-			},
-			dataTypes,
-			fresh: options.fresh || false,
-			searchType: options.searchType || "web"
-		};
-		const totalSteps = dataTypes.length;
-		let currentStep = 0;
-		for (const dataType of dataTypes) {
-			currentStep++;
-			clearLine();
-			process.stdout.write(progressBar(currentStep, totalSteps, `${dataType} (${siteName})`));
-			if (dataType === "pages") {
-				const pages = await provider.getPages(siteUrl, range);
-				output.pages = {
-					total: pages.length,
-					data: pages
-				};
-			} else if (dataType === "keywords") {
-				const keywordsData = await provider.getKeywordsWithComparison(siteUrl, range);
-				output.keywords = {
-					total: keywordsData.current.length,
-					current: keywordsData.current,
-					previous: keywordsData.previous,
-					metadata: keywordsData.metadata
-				};
-			} else if (dataType === "countries") {
-				const countriesData = await provider.getCountriesWithComparison(siteUrl, range);
-				output.countries = {
-					current: countriesData.current,
-					previous: countriesData.previous,
-					metadata: countriesData.metadata
-				};
-			} else if (dataType === "devices") {
-				const devicesData = await provider.getDevicesWithComparison(siteUrl, range);
-				output.devices = {
-					current: devicesData.current,
-					previous: devicesData.previous,
-					metadata: devicesData.metadata
-				};
-			}
-		}
-		clearLine();
-		const ext = format === "csv" ? "csv" : "json";
-		const filename = outputFile || `gsc-${siteName.replace(/\//g, "_")}-${dataTypes.join("-")}-${period.amount}${period.unit[0]}-${endDate}.${ext}`;
-		const content = format === "csv" ? exportToCSV(output) : JSON.stringify(output, null, 2);
-		await fs.writeFile(filename, content);
-		const totalItems = (output.pages?.total || 0) + (output.keywords?.total || 0) + (output.countries?.current?.length || 0) + (output.devices?.current?.length || 0);
-		logger.success(`Saved ${totalItems} items to ${filename} (source: ${provider.source})`);
-	}
-}
-async function interactiveMode(auth, dbPath, source) {
-	process.stdout.write("  Fetching sites...");
-	const sites = await getSites(googleSearchConsole(auth));
-	clearLine();
-	logger.success(`Found ${sites.length} sites`);
-	if (sites.length === 0) {
-		cancel("No sites found in your Google Search Console account.");
-		return;
-	}
-	const selectedSites = await multiselect({
-		message: "Select sites to dump data from:",
-		options: sites.map((site) => ({
-			value: site,
-			label: site
-		}))
-	});
-	if (isCancel(selectedSites) || selectedSites.length === 0) {
-		cancel("Operation cancelled.");
-		return;
-	}
-	const dataTypes = await multiselect({
-		message: "What data would you like to dump?",
-		options: [
-			{
-				value: "pages",
-				label: "Pages (URLs and performance data)",
-				hint: "recommended"
-			},
-			{
-				value: "keywords",
-				label: "Keywords (search queries and rankings)"
-			},
-			{
-				value: "countries",
-				label: "Countries (geographic performance)"
-			},
-			{
-				value: "devices",
-				label: "Devices (desktop, mobile, tablet)"
-			}
-		],
-		required: true
-	});
-	if (isCancel(dataTypes) || dataTypes.length === 0) {
-		cancel("Operation cancelled.");
-		return;
-	}
-	const periodInput = await text({
-		message: "Time period (e.g., 90d, 6m, 1y):",
-		placeholder: "180d",
-		defaultValue: "180d",
-		validate: (value) => {
-			if (!value) return void 0;
-			return parsePeriod(value) ? void 0 : "Invalid format. Use: 90d, 6m, 1y";
-		}
-	});
-	if (isCancel(periodInput)) {
-		cancel("Operation cancelled.");
-		return;
-	}
-	const formatResult = await multiselect({
-		message: "Output format:",
-		options: [{
-			value: "json",
-			label: "JSON",
-			hint: "structured data"
-		}, {
-			value: "csv",
-			label: "CSV",
-			hint: "spreadsheet compatible"
-		}],
-		required: true
-	});
-	if (isCancel(formatResult)) {
-		cancel("Operation cancelled.");
-		return;
-	}
-	let finalSource = source;
-	if (dbPath && source === "auto") {
-		const sourceResult = await select({
-			message: "Data source:",
-			options: [
-				{
-					value: "auto",
-					label: "Auto",
-					hint: "use DB if data exists, else API"
-				},
-				{
-					value: "api",
-					label: "API",
-					hint: "always fetch from Google"
-				},
-				{
-					value: "db",
-					label: "Database",
-					hint: "use synced data"
-				}
-			]
-		});
-		if (isCancel(sourceResult)) {
-			cancel("Operation cancelled.");
-			return;
-		}
-		finalSource = sourceResult;
-	}
-	const format = formatResult[0];
-	const period = parsePeriod(periodInput || "180d");
-	const ready = await confirm({ message: `Dump ${dataTypes.join(", ")} for ${selectedSites.length} site(s), ${period.amount}${period.unit[0]}, as ${format.toUpperCase()}?` });
-	if (isCancel(ready) || !ready) {
-		cancel("Operation cancelled.");
-		return;
-	}
-	console.log();
-	let db = null;
-	if (dbPath) {
-		if (await fs.access(dbPath).then(() => true).catch(() => false)) db = createGscDb(betterSqlite3({ name: path.resolve(dbPath) })).db;
+function getDimensions(dataType) {
+	switch (dataType) {
+		case "pages": return [page, date];
+		case "keywords": return [query, date];
+		case "countries": return [country, date];
+		case "devices": return [device, date];
 	}
-	const provider = getProviderForSource(auth, db, finalSource);
-	logger.info(`Using ${provider.source.toUpperCase()} as data source`);
-	await runDump(provider, selectedSites, dataTypes, period, format, null);
-}
-async function nonInteractiveMode(auth, site, data, periodStr, format, output, dbPath, source, options = {}) {
-	if (site.length === 0) {
-		logger.error("--site required in non-interactive mode");
-		process.exit(1);
-	}
-	if (data.length === 0) {
-		logger.error("--data required in non-interactive mode");
-		process.exit(1);
-	}
-	const invalidData = data.filter((d) => !DUMP_DATA_TYPES.includes(d));
-	if (invalidData.length > 0) {
-		logger.error(`Invalid data types: ${invalidData.join(", ")}`);
-		logger.info("Valid types: pages, keywords, countries, devices");
-		process.exit(1);
-	}
-	const period = parsePeriod(periodStr);
-	if (!period) {
-		logger.error(`Invalid period: ${periodStr}`);
-		logger.info("Examples: 90d, 6m, 1y");
-		process.exit(1);
-	}
-	process.stdout.write("  Validating sites...");
-	const availableSites = await getSites(googleSearchConsole(auth));
-	clearLine();
-	const normalizedSites = [];
-	for (const s of site) {
-		const match = availableSites.find((avail) => avail === s || avail === `https://${s}` || avail === `http://${s}` || avail === `sc-domain:${s}` || avail.replace(/https?:\/\//, "").replace(/\/$/, "") === s.replace(/\/$/, ""));
-		if (!match) {
-			logger.error(`Site not found: ${s}`);
-			logger.info("Available sites:");
-			availableSites.slice(0, 5).forEach((a) => console.log(`    - ${a}`));
-			if (availableSites.length > 5) console.log(`    ... and ${availableSites.length - 5} more`);
-			process.exit(1);
-		}
-		normalizedSites.push(match);
-	}
-	let db = null;
-	if (dbPath) {
-		if (await fs.access(dbPath).then(() => true).catch(() => false)) db = createGscDb(betterSqlite3({ name: path.resolve(dbPath) })).db;
-		else if (source === "db") {
-			logger.error(`Database not found: ${dbPath}`);
-			logger.info("Run 'gscdump sync' first to create the database.");
-			process.exit(1);
-		}
-	}
-	const provider = getProviderForSource(auth, db, source);
-	const extras = [];
-	if (options.fresh) extras.push("fresh");
-	if (options.searchType && options.searchType !== "web") extras.push(options.searchType);
-	const extrasStr = extras.length ? ` [${extras.join(", ")}]` : "";
-	logger.info(`${normalizedSites.length} site(s), ${data.join("+")} data, ${period.amount}${period.unit[0]}, ${format}, source: ${provider.source}${extrasStr}`);
-	console.log();
-	await runDump(provider, normalizedSites, data, period, format, output, options);
 }
 const dumpCommand = defineCommand({
 	meta: {
 		name: "dump",
-		description: "Export GSC data to JSON or CSV files"
+		description: "Export search analytics data via GSC API"
 	},
 	args: {
 		site: {
 			type: "string",
 			alias: "s",
-			description: "Site URL (comma-separated for multiple)"
-		},
-		data: {
-			type: "string",
-			alias: "d",
-			description: "Data types: pages,keywords,countries,devices"
+			description: "Site URL (e.g., sc-domain:example.com)"
 		},
-		period: {
+		output: {
 			type: "string",
-			alias: "p",
-			default: "180d",
-			description: "Time period: 90d, 6m, 1y"
+			alias: "o",
+			description: "Output file path (default: stdout)"
 		},
 		format: {
 			type: "string",
 			alias: "f",
 			default: "json",
-			description: "Output format: json, csv"
+			description: "Output format: json or csv"
 		},
-		output: {
+		start: {
 			type: "string",
-			alias: "o",
-			description: "Output filename"
+			description: "Start date (YYYY-MM-DD)"
+		},
+		end: {
+			type: "string",
+			description: "End date (YYYY-MM-DD)"
+		},
+		days: {
+			type: "string",
+			alias: "d",
+			default: "28",
+			description: "Number of days to fetch (default: 28)"
 		},
-		source: {
+		types: {
 			type: "string",
-			default: "auto",
-			description: "Data source: auto, api, db"
+			alias: "t",
+			description: "Data types: pages,keywords,countries,devices"
 		},
-		db: {
+		limit: {
 			type: "string",
-			description: "SQLite database path (for db/auto source)"
+			alias: "l",
+			default: "25000",
+			description: "Max rows per data type"
 		},
-		fresh: {
+		quiet: {
 			type: "boolean",
+			alias: "q",
 			default: false,
-			description: "Include fresh/unfinalized data (last 3 days)"
+			description: "Suppress progress output"
 		},
-		type: {
-			type: "string",
-			alias: "t",
-			default: "web",
-			description: "Search type: web, image, video, news, discover, googleNews"
+		interactive: {
+			type: "boolean",
+			alias: "i",
+			default: false,
+			description: "Interactive mode - prompts for options"
 		}
 	},
 	async run({ args }) {
 		const config = await loadConfig();
-		const siteArg = args.site || config.defaultSite;
-		const sites = siteArg ? siteArg.split(",") : [];
-		const data = args.data ? args.data.split(",") : [];
-		const periodArg = args.period === "180d" && config.defaultPeriod ? config.defaultPeriod : args.period;
-		const formatArg = args.format === "json" && config.defaultFormat ? config.defaultFormat : args.format;
-		const dbPath = args.db || config.defaultDb || null;
-		const source = [
-			"auto",
-			"api",
-			"db"
-		].includes(args.source) ? args.source : "auto";
-		const isInteractive = sites.length === 0 && data.length === 0;
 		const { getAuth: getAuth$1 } = await Promise.resolve().then(() => auth_exports);
-		const auth = await getAuth$1({
-			interactive: isInteractive,
-			config
-		});
-		const searchType = [
-			"web",
-			"image",
-			"video",
-			"news",
-			"discover",
-			"googleNews"
-		].includes(args.type) ? args.type : "web";
-		const options = {
-			fresh: args.fresh,
-			searchType
-		};
-		if (isInteractive) await interactiveMode(auth, dbPath, source);
-		else await nonInteractiveMode(auth, sites, data, periodArg, formatArg === "csv" ? "csv" : "json", args.output || null, dbPath, source, options);
-		logger.success("Done!");
-	}
-});
-
-//#endregion
-//#region src/commands/indexing.ts
-const inspectCommand = defineCommand({
-	meta: {
-		name: "inspect",
-		description: "Inspect URLs to check their indexing status (shorthand for `gscdump index inspect`)"
-	},
-	args: {
-		db: {
-			type: "string",
-			alias: "d",
-			default: "./gscdump.db",
-			description: "SQLite database path"
-		},
-		site: {
-			type: "string",
-			alias: "s",
-			description: "Site URL (e.g., sc-domain:example.com)"
-		},
-		limit: {
-			type: "string",
-			alias: "l",
-			default: "100",
-			description: "Max URLs to inspect"
-		},
-		delay: {
-			type: "string",
-			default: "200",
-			description: "Delay between requests (ms)"
-		},
-		quiet: {
-			type: "boolean",
-			alias: "q",
-			default: false,
-			description: "Suppress progress output"
-		},
-		json: {
-			type: "boolean",
-			default: false,
-			description: "Output as JSON"
-		}
-	},
-	async run({ args }) {
-		const config = await loadConfig();
-		const dbPath = String(args.db === "./gscdump.db" && config.defaultDb ? config.defaultDb : args.db);
-		const siteArg = String(args.site || config.defaultSite || "");
-		if (!siteArg) {
-			logger.error("Site required. Use --site or set defaultSite in config.");
-			process.exit(1);
-		}
-		const { getAuth: getAuth$1 } = await Promise.resolve().then(() => auth_exports);
-		const client = googleSearchConsole(await getAuth$1({
-			interactive: false,
+		const client = googleSearchConsole(await getAuth$1({
+			interactive: false,
 			config
 		}));
-		const { db, db0 } = createGscDb(betterSqlite3({ name: path.resolve(dbPath) }));
-		await setupSchema(db0);
-		await syncSites(db, client).catch(gscErrorHandler);
-		const siteRecord = await getSiteByProperty(db, siteArg);
-		if (!siteRecord) {
-			logger.error(`Site not found: ${siteArg}`);
-			process.exit(1);
-		}
-		const siteId = siteRecord.site_id || siteRecord.siteId;
-		const limit = Number.parseInt(String(args.limit), 10);
-		const delayMs = Number.parseInt(String(args.delay), 10);
-		const paths = await db.selectDistinct({ path: sitePathDateAnalytics.path }).from(sitePathDateAnalytics).where(eq(sitePathDateAnalytics.siteId, siteId)).limit(limit);
-		if (paths.length === 0) {
-			logger.warn("No URLs found. Run `gscdump sync` first.");
-			return;
-		}
-		if (!args.quiet && !args.json) logger.info(`Inspecting ${paths.length} URLs...`);
-		const results = [];
-		const stats = await batchInspectUrls(db, client, siteId, siteArg, paths.map((p) => p.path), {
-			delayMs,
-			onProgress: (result, i, total) => {
-				results.push(result);
-				if (!args.quiet && !args.json) {
-					clearLine();
-					process.stdout.write(progressBar(i + 1, total, result.path.slice(0, 40)));
-				}
+		let siteUrl = String(args.site || config.defaultSite || "");
+		if (!siteUrl || args.interactive) {
+			const verified = (await client.sites()).filter((s) => s.permissionLevel !== "siteUnverifiedUser");
+			if (verified.length === 0) {
+				logger.error("No verified sites found");
+				process.exit(1);
 			}
-		}).catch(gscErrorHandler);
-		if (!args.quiet && !args.json) clearLine();
-		if (args.json) console.log(JSON.stringify({
-			stats,
-			results
-		}, null, 2));
-		else {
-			console.log();
-			logger.success(`Inspected ${paths.length} URLs`);
-			console.log(`  Indexed:     ${stats.indexed}`);
-			console.log(`  Not Indexed: ${stats.notIndexed}`);
-			console.log(`  Errors:      ${stats.errors}`);
-			console.log();
+			const selected = await select({
+				message: "Select a site",
+				options: verified.map((s) => ({
+					value: s.siteUrl,
+					label: s.siteUrl
+				})),
+				initialValue: siteUrl || verified[0]?.siteUrl
+			});
+			if (isCancel(selected)) {
+				cancel("Cancelled");
+				process.exit(0);
+			}
+			siteUrl = selected;
 		}
-	}
-});
-const indexingCommand = defineCommand({
-	meta: {
-		name: "index",
-		description: "Manage URL indexing via Google Indexing API"
-	},
-	subCommands: {
-		status: defineCommand({
-			meta: {
-				name: "status",
-				description: "Show indexing status for URLs"
-			},
-			args: {
-				db: {
-					type: "string",
-					alias: "d",
-					default: "./gscdump.db",
-					description: "SQLite database path"
-				},
-				site: {
-					type: "string",
-					alias: "s",
-					description: "Site URL (e.g., sc-domain:example.com)"
-				},
-				json: {
-					type: "boolean",
-					default: false,
-					description: "Output as JSON"
-				}
-			},
-			async run({ args }) {
-				const config = await loadConfig();
-				const dbPath = String(args.db === "./gscdump.db" && config.defaultDb ? config.defaultDb : args.db);
-				const siteArg = String(args.site || config.defaultSite || "");
-				if (!siteArg) {
-					logger.error("Site required. Use --site or set defaultSite in config.");
-					process.exit(1);
-				}
-				const { db, db0 } = createGscDb(betterSqlite3({ name: path.resolve(dbPath) }));
-				await setupSchema(db0);
-				const siteRecord = await getSiteByProperty(db, siteArg);
-				if (!siteRecord) {
-					logger.error(`Site not found: ${siteArg}`);
-					process.exit(1);
-				}
-				const stats = await getIndexingStats(db, siteRecord.site_id || siteRecord.siteId);
-				if (args.json) console.log(JSON.stringify(stats, null, 2));
-				else {
-					console.log();
-					logger.info(`Indexing Status for ${siteArg}`);
-					console.log();
-					console.log(`  Total URLs:    ${stats.total}`);
-					console.log(`  Indexed:       ${stats.indexed} (${stats.total ? Math.round(stats.indexed / stats.total * 100) : 0}%)`);
-					console.log(`  Not Indexed:   ${stats.notIndexed}`);
-					console.log(`  Unknown:       ${stats.unknown}`);
-					console.log(`  Requested:     ${stats.requested}`);
-					console.log();
-				}
+		let startDate;
+		let endDate;
+		if (args.start && args.end) {
+			startDate = String(args.start);
+			endDate = String(args.end);
+		} else if (args.interactive) {
+			const startInput = await text({
+				message: "Start date (YYYY-MM-DD)",
+				placeholder: (/* @__PURE__ */ new Date(Date.now() - Number(args.days) * 864e5)).toISOString().split("T")[0]
+			});
+			if (isCancel(startInput)) {
+				cancel("Cancelled");
+				process.exit(0);
 			}
-		}),
-		inspect: defineCommand({
-			meta: {
-				name: "inspect",
-				description: "Inspect URLs to check their indexing status"
-			},
-			args: {
-				db: {
-					type: "string",
-					alias: "d",
-					default: "./gscdump.db",
-					description: "SQLite database path"
-				},
-				site: {
-					type: "string",
-					alias: "s",
-					description: "Site URL (e.g., sc-domain:example.com)"
-				},
-				limit: {
-					type: "string",
-					alias: "l",
-					default: "100",
-					description: "Max URLs to inspect"
-				},
-				delay: {
-					type: "string",
-					default: "200",
-					description: "Delay between requests (ms)"
-				},
-				quiet: {
-					type: "boolean",
-					alias: "q",
-					default: false,
-					description: "Suppress progress output"
-				},
-				json: {
-					type: "boolean",
-					default: false,
-					description: "Output as JSON"
-				}
-			},
-			async run({ args }) {
-				const config = await loadConfig();
-				const dbPath = String(args.db === "./gscdump.db" && config.defaultDb ? config.defaultDb : args.db);
-				const siteArg = String(args.site || config.defaultSite || "");
-				if (!siteArg) {
-					logger.error("Site required. Use --site or set defaultSite in config.");
-					process.exit(1);
-				}
-				const { getAuth: getAuth$1 } = await Promise.resolve().then(() => auth_exports);
-				const client = googleSearchConsole(await getAuth$1({
-					interactive: false,
-					config
-				}));
-				const { db, db0 } = createGscDb(betterSqlite3({ name: path.resolve(dbPath) }));
-				await setupSchema(db0);
-				await syncSites(db, client).catch(gscErrorHandler);
-				const siteRecord = await getSiteByProperty(db, siteArg);
-				if (!siteRecord) {
-					logger.error(`Site not found: ${siteArg}`);
-					process.exit(1);
-				}
-				const siteId = siteRecord.site_id || siteRecord.siteId;
-				const limit = Number.parseInt(String(args.limit), 10);
-				const delayMs = Number.parseInt(String(args.delay), 10);
-				const paths = await db.selectDistinct({ path: sitePathDateAnalytics.path }).from(sitePathDateAnalytics).where(eq(sitePathDateAnalytics.siteId, siteId)).limit(limit);
-				if (paths.length === 0) {
-					logger.warn("No URLs found. Run `gscdump sync` first.");
-					return;
-				}
-				if (!args.quiet && !args.json) logger.info(`Inspecting ${paths.length} URLs...`);
-				const results = [];
-				const stats = await batchInspectUrls(db, client, siteId, siteArg, paths.map((p) => p.path), {
-					delayMs,
-					onProgress: (result, i, total) => {
-						results.push(result);
-						if (!args.quiet && !args.json) {
-							clearLine();
-							process.stdout.write(progressBar(i + 1, total, result.path.slice(0, 40)));
-						}
-					}
-				}).catch(gscErrorHandler);
-				if (!args.quiet && !args.json) clearLine();
-				if (args.json) console.log(JSON.stringify({
-					stats,
-					results
-				}, null, 2));
-				else {
-					console.log();
-					logger.success(`Inspected ${paths.length} URLs`);
-					console.log(`  Indexed:     ${stats.indexed}`);
-					console.log(`  Not Indexed: ${stats.notIndexed}`);
-					console.log(`  Errors:      ${stats.errors}`);
-					console.log();
-				}
+			const endInput = await text({
+				message: "End date (YYYY-MM-DD)",
+				placeholder: (/* @__PURE__ */ new Date(Date.now() - 3 * 864e5)).toISOString().split("T")[0]
+			});
+			if (isCancel(endInput)) {
+				cancel("Cancelled");
+				process.exit(0);
 			}
-		}),
-		request: defineCommand({
-			meta: {
-				name: "request",
-				description: "Request indexing for URLs via Google Indexing API"
-			},
-			args: {
-				"db": {
-					type: "string",
-					alias: "d",
-					default: "./gscdump.db",
-					description: "SQLite database path"
-				},
-				"site": {
-					type: "string",
-					alias: "s",
-					description: "Site URL (e.g., sc-domain:example.com)"
-				},
-				"limit": {
-					type: "string",
-					alias: "l",
-					default: "200",
-					description: "Max URLs to request (API quota: 200/day)"
-				},
-				"delay": {
-					type: "string",
-					default: "100",
-					description: "Delay between requests (ms)"
-				},
-				"type": {
-					type: "string",
-					alias: "t",
-					default: "URL_UPDATED",
-					description: "Notification type: URL_UPDATED or URL_DELETED"
-				},
-				"not-indexed": {
-					type: "boolean",
-					default: true,
-					description: "Only request for non-indexed URLs"
-				},
-				"quiet": {
-					type: "boolean",
-					alias: "q",
-					default: false,
-					description: "Suppress progress output"
-				},
-				"json": {
-					type: "boolean",
-					default: false,
-					description: "Output as JSON"
-				}
+			startDate = String(startInput) || (/* @__PURE__ */ new Date(Date.now() - Number(args.days) * 864e5)).toISOString().split("T")[0];
+			endDate = String(endInput) || (/* @__PURE__ */ new Date(Date.now() - 3 * 864e5)).toISOString().split("T")[0];
+		} else {
+			const days = Number.parseInt(String(args.days), 10);
+			endDate = (/* @__PURE__ */ new Date(Date.now() - 3 * 864e5)).toISOString().split("T")[0];
+			startDate = (/* @__PURE__ */ new Date(Date.now() - (days + 3) * 864e5)).toISOString().split("T")[0];
+		}
+		let dataTypes;
+		if (args.types) dataTypes = String(args.types).split(",").filter((t) => DUMP_DATA_TYPES.includes(t));
+		else if (args.interactive) {
+			const selected = await multiselect({
+				message: "Select data types to export",
+				options: DUMP_DATA_TYPES.map((t) => ({
+					value: t,
+					label: t
+				})),
+				initialValues: ["pages", "keywords"]
+			});
+			if (isCancel(selected)) {
+				cancel("Cancelled");
+				process.exit(0);
+			}
+			dataTypes = selected;
+		} else dataTypes = ["pages", "keywords"];
+		const rowLimit = Number.parseInt(String(args.limit), 10);
+		const format = String(args.format);
+		const output = {
+			siteUrl,
+			dateRange: {
+				start: startDate,
+				end: endDate
 			},
-			async run({ args }) {
-				const config = await loadConfig();
-				const dbPath = String(args.db === "./gscdump.db" && config.defaultDb ? config.defaultDb : args.db);
-				const siteArg = String(args.site || config.defaultSite || "");
-				if (!siteArg) {
-					logger.error("Site required. Use --site or set defaultSite in config.");
-					process.exit(1);
-				}
-				const { getAuth: getAuth$1 } = await Promise.resolve().then(() => auth_exports);
-				const client = googleSearchConsole(await getAuth$1({
-					interactive: false,
-					config
-				}));
-				const { db, db0 } = createGscDb(betterSqlite3({ name: path.resolve(dbPath) }));
-				await setupSchema(db0);
-				await syncSites(db, client).catch(gscErrorHandler);
-				const siteRecord = await getSiteByProperty(db, siteArg);
-				if (!siteRecord) {
-					logger.error(`Site not found: ${siteArg}`);
-					process.exit(1);
-				}
-				const siteId = siteRecord.site_id || siteRecord.siteId;
-				const limit = Number.parseInt(String(args.limit), 10);
-				const delayMs = Number.parseInt(String(args.delay), 10);
-				const type = String(args.type);
-				const paths = await db.selectDistinct({ path: sitePathDateAnalytics.path }).from(sitePathDateAnalytics).where(eq(sitePathDateAnalytics.siteId, siteId)).limit(limit);
-				if (paths.length === 0) {
-					logger.warn("No URLs found. Run `gscdump sync` first.");
-					return;
-				}
-				if (!args.quiet && !args.json) {
-					logger.info(`Requesting indexing for ${paths.length} URLs...`);
-					logger.warn("Note: Indexing API quota is typically 200 requests/day");
-				}
-				const results = [];
-				const stats = await batchRequestIndexingForPaths(db, client, siteId, siteArg, paths.map((p) => p.path), {
-					type,
-					delayMs,
-					onProgress: (result, i, total) => {
-						results.push(result);
-						if (!args.quiet && !args.json) {
-							clearLine();
-							const status = result.error ? "ERR" : "OK";
-							process.stdout.write(progressBar(i + 1, total, `[${status}] ${result.url.slice(-40)}`));
-						}
-					}
-				}).catch(gscErrorHandler);
-				if (!args.quiet && !args.json) clearLine();
-				if (args.json) console.log(JSON.stringify({
-					stats,
-					results
-				}, null, 2));
-				else {
-					console.log();
-					logger.success(`Requested indexing for ${paths.length} URLs`);
-					console.log(`  Success: ${stats.success}`);
-					console.log(`  Errors:  ${stats.errors}`);
-					console.log();
-					if (stats.errors > 0) {
-						const errorResults = results.filter((r) => r.error);
-						logger.warn("Errors:");
-						errorResults.slice(0, 5).forEach((r) => {
-							console.log(`  ${r.url}: ${r.error}`);
-						});
-						if (errorResults.length > 5) console.log(`  ... and ${errorResults.length - 5} more`);
-					}
-				}
+			exportedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		const totalSteps = dataTypes.length;
+		let currentStep = 0;
+		for (const dataType of dataTypes) {
+			currentStep++;
+			if (!args.quiet) {
+				clearLine();
+				process.stdout.write(progressBar(currentStep, totalSteps, dataType));
 			}
-		})
+			const dimensions = getDimensions(dataType);
+			const builder = gsc.select(...dimensions).where(between(date, startDate, endDate)).limit(rowLimit);
+			const rows = [];
+			for await (const batch of client.query(siteUrl, builder)) rows.push(...batch);
+			output[dataType] = {
+				total: rows.length,
+				data: rows
+			};
+		}
+		if (!args.quiet) {
+			clearLine();
+			logger.success(`Exported ${dataTypes.join(", ")} for ${siteUrl}`);
+		}
+		const content = format === "csv" ? exportToCSV(output) : JSON.stringify(output, null, 2);
+		if (args.output) {
+			await fs.writeFile(String(args.output), content);
+			if (!args.quiet) logger.info(`Written to ${args.output}`);
+		} else console.log(content);
 	}
 });
 
@@ -1908,6 +862,383 @@ const initCommand = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/mcp/handlers/analytics.ts
+async function collectRows(ctx, siteUrl, builder) {
+	const rows = [];
+	for await (const batch of ctx.client.query(siteUrl, builder)) rows.push(...batch);
+	return rows;
+}
+async function fetchPages(input, ctx) {
+	const builder = gsc.select(page, date).where(between(date, input.period.start, input.period.end)).limit(25e3);
+	const rows = await collectRows(ctx, input.siteUrl, builder);
+	return {
+		total: rows.length,
+		data: rows
+	};
+}
+async function fetchKeywords(input, ctx) {
+	const builder = gsc.select(query, date).where(between(date, input.period.start, input.period.end)).limit(25e3);
+	const rows = await collectRows(ctx, input.siteUrl, builder);
+	return {
+		total: rows.length,
+		data: rows
+	};
+}
+async function fetchCountries(input, ctx) {
+	const builder = gsc.select(country, date).where(between(date, input.period.start, input.period.end)).limit(25e3);
+	const rows = await collectRows(ctx, input.siteUrl, builder);
+	return {
+		total: rows.length,
+		data: rows
+	};
+}
+async function fetchDevices(input, ctx) {
+	const builder = gsc.select(device, date).where(between(date, input.period.start, input.period.end)).limit(25e3);
+	const rows = await collectRows(ctx, input.siteUrl, builder);
+	return {
+		total: rows.length,
+		data: rows
+	};
+}
+
+//#endregion
+//#region src/mcp/handlers/indexing.ts
+async function inspectUrl$1(input, ctx) {
+	return inspectUrl(ctx.client, input.siteUrl, input.inspectionUrl);
+}
+async function requestIndexing$1(input, ctx) {
+	return requestIndexing(ctx.client, input.url, { type: input.type || "URL_UPDATED" }).catch((e) => ({
+		url: input.url,
+		type: input.type || "URL_UPDATED",
+		error: e.message
+	}));
+}
+async function getIndexingStatus(input, ctx) {
+	return getIndexingMetadata(ctx.client, input.url).catch((e) => ({
+		url: input.url,
+		error: e.message
+	}));
+}
+async function batchRequestIndexing$1(input, ctx) {
+	const results = await batchRequestIndexing(ctx.client, input.urls, {
+		type: input.type || "URL_UPDATED",
+		delayMs: input.delayMs || 100
+	});
+	return {
+		results,
+		success: results.length,
+		failed: 0
+	};
+}
+async function batchInspectUrls$1(input, ctx) {
+	const results = await batchInspectUrls(ctx.client, input.siteUrl, input.urls, { delayMs: input.delayMs || 200 });
+	return {
+		results,
+		indexed: results.filter((r) => r.isIndexed).length,
+		notIndexed: results.filter((r) => !r.isIndexed).length
+	};
+}
+
+//#endregion
+//#region src/mcp/handlers/query.ts
+const DIMENSION_MAP$1 = {
+	page,
+	query,
+	date,
+	country,
+	device,
+	searchAppearance
+};
+async function customQuery(input, ctx) {
+	const dimensions = input.dimensions.filter((d) => d in DIMENSION_MAP$1).map((d) => DIMENSION_MAP$1[d]);
+	if (dimensions.length === 0) throw new Error("At least one valid dimension required");
+	const builder = gsc.select(...dimensions).where(between(date, input.period.start, input.period.end)).limit(input.rowLimit || 25e3);
+	const rows = [];
+	for await (const batch of ctx.client.query(input.siteUrl, builder)) rows.push(...batch);
+	return {
+		total: rows.length,
+		data: rows
+	};
+}
+
+//#endregion
+//#region src/mcp/handlers/sites.ts
+async function listSites(_input, ctx) {
+	return fetchSites(ctx.client);
+}
+async function listSitesWithSitemaps(_input, ctx) {
+	return fetchSitesWithSitemaps(ctx.client);
+}
+async function listSitemaps(input, ctx) {
+	return fetchSitemaps(ctx.client, input.siteUrl);
+}
+async function getSitemap(input, ctx) {
+	return fetchSitemap(ctx.client, input.siteUrl, input.feedpath);
+}
+async function submitSitemap$1(input, ctx) {
+	await submitSitemap(ctx.client, input.siteUrl, input.feedpath);
+	return { success: true };
+}
+async function deleteSitemap$1(input, ctx) {
+	await deleteSitemap(ctx.client, input.siteUrl, input.feedpath);
+	return { success: true };
+}
+
+//#endregion
+//#region src/mcp/types.ts
+const periodSchema = z.object({
+	start: z.string().describe("Start date (YYYY-MM-DD)"),
+	end: z.string().describe("End date (YYYY-MM-DD)")
+}).describe("Date range for the query");
+const siteUrlSchema = z.string().describe("GSC property URL (e.g., sc-domain:example.com or https://example.com/)");
+const queryOptionsSchema = z.object({
+	type: z.enum([
+		"web",
+		"image",
+		"video",
+		"news",
+		"discover",
+		"googleNews"
+	]).optional().describe("Data type"),
+	dataState: z.enum(["final", "all"]).optional().describe("Data state: final (settled) or all (includes fresh)"),
+	aggregationType: z.enum(["byPage", "byProperty"]).optional().describe("Aggregation: byPage or byProperty")
+}).optional();
+const listSitesInput = z.object({});
+const listSitemapsInput = z.object({ siteUrl: siteUrlSchema });
+const fetchAnalyticsInput = z.object({
+	siteUrl: siteUrlSchema,
+	period: periodSchema,
+	comparePrevious: z.boolean().optional().describe("Include previous period comparison"),
+	options: queryOptionsSchema
+});
+const fetchPageInput = z.object({
+	siteUrl: siteUrlSchema,
+	period: periodSchema,
+	url: z.string().describe("Page URL to fetch details for")
+});
+const fetchKeywordInput = z.object({
+	siteUrl: siteUrlSchema,
+	period: periodSchema,
+	keyword: z.string().describe("Keyword to fetch details for")
+});
+const inspectUrlInput = z.object({
+	siteUrl: siteUrlSchema,
+	inspectionUrl: z.string().describe("URL to inspect")
+});
+const requestIndexingInput = z.object({
+	url: z.string().describe("URL to request indexing for"),
+	type: z.enum(["URL_UPDATED", "URL_DELETED"]).optional().describe("Notification type")
+});
+const getIndexingStatusInput = z.object({ url: z.string().describe("URL to get indexing status for") });
+const customQueryInput = z.object({
+	siteUrl: siteUrlSchema,
+	period: periodSchema,
+	dimensions: z.array(z.enum([
+		"date",
+		"query",
+		"page",
+		"country",
+		"device",
+		"searchAppearance"
+	])).describe("Dimensions to group by"),
+	rowLimit: z.number().optional().describe("Max rows (default 25000)"),
+	options: queryOptionsSchema
+});
+const sitemapInput = z.object({
+	siteUrl: siteUrlSchema,
+	feedpath: z.string().describe("Sitemap URL (e.g., https://example.com/sitemap.xml)")
+});
+const batchRequestIndexingInput = z.object({
+	urls: z.array(z.string()).describe("URLs to request indexing for"),
+	type: z.enum(["URL_UPDATED", "URL_DELETED"]).optional().describe("Notification type"),
+	delayMs: z.number().optional().describe("Delay between requests in ms (default 100)")
+});
+const batchInspectUrlsInput = z.object({
+	siteUrl: siteUrlSchema,
+	urls: z.array(z.string()).describe("URLs to inspect"),
+	delayMs: z.number().optional().describe("Delay between requests in ms (default 200)")
+});
+
+//#endregion
+//#region src/mcp/server/index.ts
+function createGscMcpServer(options) {
+	const { name = "gscdump", version = "1.0.0", getAuth: getAuth$1 } = options;
+	const server = new McpServer({
+		name,
+		version
+	});
+	const auth = async () => Promise.resolve(getAuth$1());
+	const getContext = async () => {
+		const a = await auth();
+		return {
+			auth: a,
+			client: googleSearchConsole(a)
+		};
+	};
+	server.registerTool("list-sites", {
+		description: "List all Google Search Console sites the user has access to",
+		inputSchema: listSitesInput.shape
+	}, async (args) => {
+		const result = await listSites(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("list-sites-with-sitemaps", {
+		description: "List all GSC sites with their sitemaps",
+		inputSchema: listSitesInput.shape
+	}, async (args) => {
+		const result = await listSitesWithSitemaps(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("list-sitemaps", {
+		description: "List sitemaps for a specific site",
+		inputSchema: listSitemapsInput.shape
+	}, async (args) => {
+		const result = await listSitemaps(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("get-sitemap", {
+		description: "Get details for a specific sitemap",
+		inputSchema: sitemapInput.shape
+	}, async (args) => {
+		const result = await getSitemap(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("submit-sitemap", {
+		description: "Submit a sitemap to Google Search Console",
+		inputSchema: sitemapInput.shape
+	}, async (args) => {
+		const result = await submitSitemap$1(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("delete-sitemap", {
+		description: "Delete a sitemap from Google Search Console",
+		inputSchema: sitemapInput.shape
+	}, async (args) => {
+		const result = await deleteSitemap$1(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("fetch-pages", {
+		description: "Fetch page analytics data for a site",
+		inputSchema: fetchAnalyticsInput.shape
+	}, async (args) => {
+		const result = await fetchPages(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("fetch-keywords", {
+		description: "Fetch keyword/query analytics data for a site",
+		inputSchema: fetchAnalyticsInput.shape
+	}, async (args) => {
+		const result = await fetchKeywords(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("fetch-countries", {
+		description: "Fetch country analytics data for a site",
+		inputSchema: fetchAnalyticsInput.shape
+	}, async (args) => {
+		const result = await fetchCountries(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("fetch-devices", {
+		description: "Fetch device analytics data for a site",
+		inputSchema: fetchAnalyticsInput.shape
+	}, async (args) => {
+		const result = await fetchDevices(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("custom-query", {
+		description: "Run a custom search analytics query with specified dimensions",
+		inputSchema: customQueryInput.shape
+	}, async (args) => {
+		const result = await customQuery(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("inspect-url", {
+		description: "Inspect a URL in Google Search Console to check its indexing status",
+		inputSchema: inspectUrlInput.shape
+	}, async (args) => {
+		const result = await inspectUrl$1(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("request-indexing", {
+		description: "Request Google to index or remove a URL via the Indexing API",
+		inputSchema: requestIndexingInput.shape
+	}, async (args) => {
+		const result = await requestIndexing$1(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("get-indexing-status", {
+		description: "Get indexing status metadata for a URL",
+		inputSchema: getIndexingStatusInput.shape
+	}, async (args) => {
+		const result = await getIndexingStatus(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("batch-request-indexing", {
+		description: "Batch request indexing for multiple URLs with rate limiting",
+		inputSchema: batchRequestIndexingInput.shape
+	}, async (args) => {
+		const result = await batchRequestIndexing$1(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	server.registerTool("batch-inspect-urls", {
+		description: "Batch inspect multiple URLs to check their indexing status",
+		inputSchema: batchInspectUrlsInput.shape
+	}, async (args) => {
+		const result = await batchInspectUrls$1(args, await getContext());
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	});
+	return server;
+}
+
 //#endregion
 //#region src/commands/mcp.ts
 async function checkAuth() {
@@ -1969,6 +1300,177 @@ const mcpCommand = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/commands/query.ts
+const DIMENSION_MAP = {
+	page,
+	query,
+	date,
+	country,
+	device,
+	searchAppearance
+};
+const queryCommand = defineCommand({
+	meta: {
+		name: "query",
+		description: "Run custom search analytics queries"
+	},
+	args: {
+		site: {
+			type: "string",
+			alias: "s",
+			description: "Site URL (e.g., sc-domain:example.com)"
+		},
+		dimensions: {
+			type: "string",
+			alias: "d",
+			description: "Dimensions: page,query,date,country,device,searchAppearance"
+		},
+		start: {
+			type: "string",
+			description: "Start date (YYYY-MM-DD)"
+		},
+		end: {
+			type: "string",
+			description: "End date (YYYY-MM-DD)"
+		},
+		limit: {
+			type: "string",
+			alias: "l",
+			default: "1000",
+			description: "Max rows (default: 1000)"
+		},
+		output: {
+			type: "string",
+			alias: "o",
+			description: "Output file path (default: stdout)"
+		},
+		format: {
+			type: "string",
+			alias: "f",
+			default: "json",
+			description: "Output format: json or csv"
+		},
+		quiet: {
+			type: "boolean",
+			alias: "q",
+			default: false,
+			description: "Suppress progress output"
+		},
+		interactive: {
+			type: "boolean",
+			alias: "i",
+			default: false,
+			description: "Interactive mode"
+		}
+	},
+	async run({ args }) {
+		const config = await loadConfig();
+		const { getAuth: getAuth$1 } = await Promise.resolve().then(() => auth_exports);
+		const client = googleSearchConsole(await getAuth$1({
+			interactive: false,
+			config
+		}));
+		let siteUrl = String(args.site || config.defaultSite || "");
+		if (!siteUrl || args.interactive) {
+			const verified = (await client.sites()).filter((s) => s.permissionLevel !== "siteUnverifiedUser");
+			if (verified.length === 0) {
+				logger.error("No verified sites found");
+				process.exit(1);
+			}
+			const selected = await select({
+				message: "Select a site",
+				options: verified.map((s) => ({
+					value: s.siteUrl,
+					label: s.siteUrl
+				})),
+				initialValue: siteUrl || verified[0]?.siteUrl
+			});
+			if (isCancel(selected)) {
+				cancel("Cancelled");
+				process.exit(0);
+			}
+			siteUrl = selected;
+		}
+		let dimensions;
+		if (args.dimensions) dimensions = String(args.dimensions).split(",").filter((d) => d in DIMENSION_MAP).map((d) => DIMENSION_MAP[d]);
+		else if (args.interactive) {
+			const selected = await multiselect({
+				message: "Select dimensions",
+				options: Object.keys(DIMENSION_MAP).map((d) => ({
+					value: d,
+					label: d
+				})),
+				initialValues: ["page", "query"]
+			});
+			if (isCancel(selected)) {
+				cancel("Cancelled");
+				process.exit(0);
+			}
+			dimensions = selected.map((d) => DIMENSION_MAP[d]);
+		} else dimensions = [page, query];
+		let startDate;
+		let endDate;
+		if (args.start && args.end) {
+			startDate = String(args.start);
+			endDate = String(args.end);
+		} else if (args.interactive) {
+			const startInput = await text({
+				message: "Start date (YYYY-MM-DD)",
+				placeholder: (/* @__PURE__ */ new Date(Date.now() - 28 * 864e5)).toISOString().split("T")[0]
+			});
+			if (isCancel(startInput)) {
+				cancel("Cancelled");
+				process.exit(0);
+			}
+			const endInput = await text({
+				message: "End date (YYYY-MM-DD)",
+				placeholder: (/* @__PURE__ */ new Date(Date.now() - 3 * 864e5)).toISOString().split("T")[0]
+			});
+			if (isCancel(endInput)) {
+				cancel("Cancelled");
+				process.exit(0);
+			}
+			startDate = String(startInput) || (/* @__PURE__ */ new Date(Date.now() - 28 * 864e5)).toISOString().split("T")[0];
+			endDate = String(endInput) || (/* @__PURE__ */ new Date(Date.now() - 3 * 864e5)).toISOString().split("T")[0];
+		} else {
+			endDate = (/* @__PURE__ */ new Date(Date.now() - 3 * 864e5)).toISOString().split("T")[0];
+			startDate = (/* @__PURE__ */ new Date(Date.now() - 31 * 864e5)).toISOString().split("T")[0];
+		}
+		const rowLimit = Number.parseInt(String(args.limit), 10);
+		const format = String(args.format);
+		const builder = gsc.select(...dimensions).where(between(date, startDate, endDate)).limit(rowLimit);
+		if (!args.quiet) logger.info(`Querying ${siteUrl}...`);
+		const rows = [];
+		for await (const batch of client.query(siteUrl, builder)) {
+			rows.push(...batch);
+			if (!args.quiet) {
+				clearLine();
+				process.stdout.write(progressBar(rows.length, rowLimit, `${rows.length} rows`));
+			}
+		}
+		if (!args.quiet) {
+			clearLine();
+			logger.success(`Fetched ${rows.length} rows`);
+		}
+		const output = {
+			siteUrl,
+			dimensions: dimensions.map((d) => String(d)),
+			dateRange: {
+				start: startDate,
+				end: endDate
+			},
+			total: rows.length,
+			data: rows
+		};
+		const content = format === "csv" ? exportToCSV(output) : JSON.stringify(output, null, 2);
+		if (args.output) {
+			await fs.writeFile(String(args.output), content);
+			if (!args.quiet) logger.info(`Written to ${args.output}`);
+		} else console.log(content);
+	}
+});
+
 //#endregion
 //#region src/commands/sitemaps.ts
 const listCommand = defineCommand({
@@ -2146,249 +1648,6 @@ const sitesCommand = defineCommand({
 	}
 });
 
-//#endregion
-//#region src/commands/sync.ts
-function parsePeriodDays(period) {
-	if (period === "max") return 480;
-	if (period.endsWith("y")) return Number.parseInt(period) * 365;
-	if (period.endsWith("m") || period.endsWith("mo")) return Number.parseInt(period) * 30;
-	return Number.parseInt(period.replace("d", ""));
-}
-async function runSync(client, dbPath, siteArg, period, granular, options) {
-	const resolvedPath = path.resolve(dbPath);
-	const report = {
-		database: resolvedPath,
-		period: {
-			start: "",
-			end: ""
-		},
-		sites: [],
-		totalRows: 0
-	};
-	if (!options.quiet && !options.json) logger.info(`Database: ${resolvedPath}`);
-	const { db, db0 } = createGscDb(betterSqlite3({ name: resolvedPath }));
-	await setupSchema(db0);
-	if (!options.quiet && !options.json) logger.start("Syncing sites...");
-	const syncedSites = await syncSites(db, client);
-	if (!options.quiet && !options.json) logger.success(`Synced ${syncedSites.length} sites`);
-	let sitesToSync = [];
-	if (siteArg) {
-		const siteRecord = await getSiteByProperty(db, siteArg);
-		if (!siteRecord) {
-			if (options.json) console.log(JSON.stringify({ error: `Site not found: ${siteArg}` }));
-			else {
-				logger.error(`Site not found: ${siteArg}`);
-				logger.info("Available sites:");
-				syncedSites.slice(0, 5).forEach((s) => console.log(`    - ${s.property}`));
-			}
-			process.exit(1);
-		}
-		sitesToSync = [{
-			siteId: siteRecord.site_id || siteRecord.siteId,
-			siteUrl: siteRecord.property
-		}];
-	} else sitesToSync = syncedSites.map((s) => ({
-		siteId: s.siteId,
-		siteUrl: s.property
-	}));
-	const periodDays = parsePeriodDays(period);
-	const daysOffset = options.fresh ? 1 : 3;
-	const adjustedEndDate = daysAgo(daysOffset);
-	const baseStartDate = daysAgo(periodDays + daysOffset);
-	const adjustedPrevEndDate = daysAgo(periodDays + daysOffset + 1);
-	const adjustedPrevStartDate = daysAgo(periodDays * 2 + daysOffset);
-	const getRangeForSite = async (siteId) => {
-		let startDate = baseStartDate;
-		if (options.since) startDate = options.since;
-		else if (options.incremental) {
-			const lastSynced = await getLastSyncedDate(db, siteId);
-			if (lastSynced) {
-				const incrementalStart = dayjs(lastSynced).add(1, "day").format("YYYY-MM-DD");
-				startDate = incrementalStart > baseStartDate ? incrementalStart : baseStartDate;
-			}
-		}
-		if (startDate > adjustedEndDate) return {
-			range: {
-				period: {
-					start: startDate,
-					end: adjustedEndDate
-				},
-				prevPeriod: {
-					start: adjustedPrevStartDate,
-					end: adjustedPrevEndDate
-				}
-			},
-			startDate,
-			skipped: true
-		};
-		return {
-			range: {
-				period: {
-					start: startDate,
-					end: adjustedEndDate
-				},
-				prevPeriod: {
-					start: adjustedPrevStartDate,
-					end: adjustedPrevEndDate
-				}
-			},
-			startDate,
-			skipped: false
-		};
-	};
-	report.period = {
-		start: options.since || baseStartDate,
-		end: adjustedEndDate
-	};
-	if (!options.quiet && !options.json) {
-		const modeNote = options.incremental ? " (incremental)" : options.since ? ` (since ${options.since})` : options.fresh ? " (fresh)" : "";
-		logger.info(`Period: ${options.since || baseStartDate} to ${adjustedEndDate}${modeNote}`);
-		console.log();
-	}
-	const dataTypes = granular ? [
-		"pages",
-		"keywords",
-		"keyword-paths",
-		"countries",
-		"devices"
-	] : [
-		"pages",
-		"keywords",
-		"countries",
-		"devices"
-	];
-	for (const { siteId, siteUrl } of sitesToSync) {
-		const siteName = siteUrl.replace(/^(sc-domain:|https?:\/\/)/, "");
-		const { range, startDate, skipped } = await getRangeForSite(siteId);
-		if (skipped) {
-			if (!options.quiet && !options.json) logger.info(`${siteName} is up to date (last synced: ${startDate})`);
-			continue;
-		}
-		const siteReport = {
-			site: siteUrl,
-			rows: {
-				pages: 0,
-				keywords: 0,
-				countries: 0,
-				devices: 0,
-				total: 0
-			}
-		};
-		if (!options.quiet && !options.json && (options.incremental || options.since)) logger.info(`${siteName}: syncing ${startDate} to ${adjustedEndDate}`);
-		for (let i = 0; i < dataTypes.length; i++) {
-			const dataType = dataTypes[i];
-			if (!options.quiet && !options.json) {
-				clearLine();
-				process.stdout.write(progressBar(i + 1, dataTypes.length, `${dataType} (${siteName})`));
-			}
-			let rows = [];
-			if (dataType === "pages") {
-				rows = await syncPages(db, client, siteId, siteUrl, range);
-				siteReport.rows.pages = rows.length;
-			} else if (dataType === "keywords") {
-				rows = await syncKeywords(db, client, siteId, siteUrl, range);
-				siteReport.rows.keywords = rows.length;
-			} else if (dataType === "keyword-paths") {
-				rows = await syncKeywordPaths(db, client, siteId, siteUrl, range);
-				siteReport.rows.keywordPaths = rows.length;
-			} else if (dataType === "countries") {
-				rows = await syncCountries(db, client, siteId, siteUrl, range);
-				siteReport.rows.countries = rows.length;
-			} else if (dataType === "devices") {
-				rows = await syncDevices(db, client, siteId, siteUrl, range);
-				siteReport.rows.devices = rows.length;
-			}
-			siteReport.rows.total += rows.length;
-		}
-		if (!options.quiet && !options.json) clearLine();
-		await updateLastSynced(db, siteId);
-		report.sites.push(siteReport);
-		report.totalRows += siteReport.rows.total;
-		if (!options.quiet && !options.json) logger.success(`Synced ${siteName} (${siteReport.rows.total.toLocaleString()} rows)`);
-	}
-	if (!options.quiet && !options.json) {
-		console.log();
-		logger.success(`Database saved to ${resolvedPath}`);
-	}
-	return report;
-}
-const syncCommand = defineCommand({
-	meta: {
-		name: "sync",
-		description: "Sync GSC data to SQLite database"
-	},
-	args: {
-		db: {
-			type: "string",
-			alias: "d",
-			default: "./gscdump.db",
-			description: "SQLite database path"
-		},
-		site: {
-			type: "string",
-			alias: "s",
-			description: "Site URL (e.g., sc-domain:example.com)"
-		},
-		period: {
-			type: "string",
-			alias: "p",
-			default: "90d",
-			description: "Time period: 90d, 6m, 1y, max (all GSC history ~16mo)"
-		},
-		granular: {
-			type: "boolean",
-			alias: "g",
-			default: false,
-			description: "Include keyword-per-page data (large dataset)"
-		},
-		quiet: {
-			type: "boolean",
-			alias: "q",
-			default: false,
-			description: "Suppress output"
-		},
-		json: {
-			type: "boolean",
-			default: false,
-			description: "Output sync report as JSON"
-		},
-		fresh: {
-			type: "boolean",
-			default: false,
-			description: "Include fresh/unfinalized data (last 3 days)"
-		},
-		incremental: {
-			type: "boolean",
-			alias: "i",
-			default: false,
-			description: "Only fetch data since last sync"
-		},
-		since: {
-			type: "string",
-			description: "Fetch data from specific date (YYYY-MM-DD)"
-		}
-	},
-	async run({ args }) {
-		const config = await loadConfig();
-		const dbPath = args.db === "./gscdump.db" && config.defaultDb ? config.defaultDb : args.db;
-		const siteArg = args.site || config.defaultSite || null;
-		const periodArg = args.period === "90d" && config.defaultPeriod ? config.defaultPeriod : args.period;
-		const { getAuth: getAuth$1 } = await Promise.resolve().then(() => auth_exports);
-		const report = await runSync(googleSearchConsole(await getAuth$1({
-			interactive: false,
-			config
-		})), dbPath, siteArg, periodArg, args.granular, {
-			quiet: args.quiet,
-			json: args.json,
-			fresh: args.fresh,
-			incremental: args.incremental,
-			since: args.since
-		}).catch(gscErrorHandler);
-		if (args.json) console.log(JSON.stringify(report, null, 2));
-		else if (!args.quiet) logger.success("Done!");
-	}
-});
-
 //#endregion
 //#region src/index.ts
 runMain(defineCommand({
@@ -2400,26 +1659,15 @@ runMain(defineCommand({
 	subCommands: {
 		init: initCommand,
 		dump: dumpCommand,
-		sync: syncCommand,
-		compare: compareCommand,
-		analyze: analyzeCommand,
+		query: queryCommand,
 		sites: sitesCommand,
 		sitemaps: sitemapsCommand,
-		index: indexingCommand,
-		inspect: inspectCommand,
 		auth: authCommand,
 		config: configCommand,
 		mcp: mcpCommand
 	},
 	setup() {
 		if (!process.argv.includes("mcp")) showSplash();
-	},
-	async run({ args }) {
-		if (!args._.length) await dumpCommand.run({
-			args,
-			rawArgs: [],
-			cmd: dumpCommand
-		});
 	}
 }));