trendsearch 0.0.1

package/dist/cli.mjs

@@ -0,0 +1,1444 @@
+import { a as UnexpectedResponseError, c as RateLimitError, l as EndpointUnavailableError, n as schemas, o as TransportError, r as pickerRequestSchema, s as SchemaValidationError, t as createClient } from "./create-client-B1euQ5Of.mjs";
+import { Command, CommanderError, Option } from "commander";
+import Conf from "conf";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { cancel, confirm, intro, isCancel, outro, select, text } from "@clack/prompts";
+
+//#region src/cli/config.ts
+const createCliConfigStore = (options = {}) => {
+	const store = new Conf({
+		projectName: "trendsearch",
+		configName: "cli",
+		cwd: options.cwd
+	});
+	return {
+		all: () => ({ ...store.store }),
+		get: (key) => store.get(key),
+		set: (key, value) => {
+			store.set(key, value);
+		},
+		delete: (key) => {
+			store.delete(key);
+		},
+		clear: () => {
+			store.clear();
+		}
+	};
+};
+const outputModes = new Set([
+	"pretty",
+	"json",
+	"jsonl"
+]);
+const pickFirst = (...values) => {
+	for (const value of values) if (value !== void 0) return value;
+};
+const toNumberOrUndefined = (value) => {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value !== "string" || value.length === 0) return;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : void 0;
+};
+const toBooleanOrUndefined = (value) => {
+	if (typeof value === "boolean") return value;
+	if (typeof value !== "string") return;
+	const normalized = value.trim().toLowerCase();
+	if ([
+		"1",
+		"true",
+		"yes",
+		"on"
+	].includes(normalized)) return true;
+	if ([
+		"0",
+		"false",
+		"no",
+		"off"
+	].includes(normalized)) return false;
+};
+const toOutputModeOrUndefined = (value) => {
+	if (typeof value !== "string") return;
+	if (!outputModes.has(value)) return;
+	return value;
+};
+const readEnv = (env) => ({
+	output: toOutputModeOrUndefined(env.TRENDSEARCH_OUTPUT),
+	spinner: toBooleanOrUndefined(env.TRENDSEARCH_SPINNER),
+	hl: env.TRENDSEARCH_HL,
+	tz: toNumberOrUndefined(env.TRENDSEARCH_TZ),
+	baseUrl: env.TRENDSEARCH_BASE_URL,
+	timeoutMs: toNumberOrUndefined(env.TRENDSEARCH_TIMEOUT_MS),
+	maxRetries: toNumberOrUndefined(env.TRENDSEARCH_MAX_RETRIES),
+	retryBaseDelayMs: toNumberOrUndefined(env.TRENDSEARCH_RETRY_BASE_DELAY_MS),
+	retryMaxDelayMs: toNumberOrUndefined(env.TRENDSEARCH_RETRY_MAX_DELAY_MS),
+	maxConcurrent: toNumberOrUndefined(env.TRENDSEARCH_MAX_CONCURRENT),
+	minDelayMs: toNumberOrUndefined(env.TRENDSEARCH_MIN_DELAY_MS),
+	userAgent: env.TRENDSEARCH_USER_AGENT
+});
+const readStored = (store) => ({
+	output: toOutputModeOrUndefined(store.get("output")),
+	spinner: toBooleanOrUndefined(store.get("spinner")),
+	hl: typeof store.get("hl") === "string" ? store.get("hl") : void 0,
+	tz: toNumberOrUndefined(store.get("tz")),
+	baseUrl: typeof store.get("baseUrl") === "string" ? store.get("baseUrl") : void 0,
+	timeoutMs: toNumberOrUndefined(store.get("timeoutMs")),
+	maxRetries: toNumberOrUndefined(store.get("maxRetries")),
+	retryBaseDelayMs: toNumberOrUndefined(store.get("retryBaseDelayMs")),
+	retryMaxDelayMs: toNumberOrUndefined(store.get("retryMaxDelayMs")),
+	maxConcurrent: toNumberOrUndefined(store.get("maxConcurrent")),
+	minDelayMs: toNumberOrUndefined(store.get("minDelayMs")),
+	userAgent: typeof store.get("userAgent") === "string" ? store.get("userAgent") : void 0
+});
+const resolveGlobalOptions = (args) => {
+	const env = readEnv(args.env);
+	const stored = readStored(args.store);
+	const outputDefault = args.stdoutIsTty ? "pretty" : "json";
+	const output = pickFirst(args.flags.output, env.output, stored.output, outputDefault) ?? outputDefault;
+	const spinner = pickFirst(args.flags.spinner, env.spinner, stored.spinner, true) ?? true;
+	return {
+		output,
+		raw: args.flags.raw ?? false,
+		spinner,
+		hl: pickFirst(args.flags.hl, env.hl, stored.hl),
+		tz: pickFirst(args.flags.tz, env.tz, stored.tz),
+		baseUrl: pickFirst(args.flags.baseUrl, env.baseUrl, stored.baseUrl),
+		timeoutMs: pickFirst(args.flags.timeoutMs, env.timeoutMs, stored.timeoutMs),
+		maxRetries: pickFirst(args.flags.maxRetries, env.maxRetries, stored.maxRetries),
+		retryBaseDelayMs: pickFirst(args.flags.retryBaseDelayMs, env.retryBaseDelayMs, stored.retryBaseDelayMs),
+		retryMaxDelayMs: pickFirst(args.flags.retryMaxDelayMs, env.retryMaxDelayMs, stored.retryMaxDelayMs),
+		maxConcurrent: pickFirst(args.flags.maxConcurrent, env.maxConcurrent, stored.maxConcurrent),
+		minDelayMs: pickFirst(args.flags.minDelayMs, env.minDelayMs, stored.minDelayMs),
+		userAgent: pickFirst(args.flags.userAgent, env.userAgent, stored.userAgent),
+		input: args.flags.input
+	};
+};
+const toCreateClientConfig = (options) => ({
+	baseUrl: options.baseUrl,
+	timeoutMs: options.timeoutMs,
+	hl: options.hl,
+	tz: options.tz,
+	userAgent: options.userAgent,
+	retries: options.maxRetries !== void 0 || options.retryBaseDelayMs !== void 0 || options.retryMaxDelayMs !== void 0 ? {
+		maxRetries: options.maxRetries,
+		baseDelayMs: options.retryBaseDelayMs,
+		maxDelayMs: options.retryMaxDelayMs
+	} : void 0,
+	rateLimit: options.maxConcurrent !== void 0 || options.minDelayMs !== void 0 ? {
+		maxConcurrent: options.maxConcurrent,
+		minDelayMs: options.minDelayMs
+	} : void 0
+});
+
+//#endregion
+//#region src/cli/errors.ts
+const EXIT_CODES = {
+	ok: 0,
+	unknown: 1,
+	usage: 2,
+	endpointUnavailable: 3,
+	rateLimited: 4,
+	transport: 5,
+	schemaDrift: 6
+};
+var CliUsageError = class extends Error {
+	details;
+	constructor(message, details) {
+		super(message);
+		this.name = "CliUsageError";
+		this.details = details;
+	}
+};
+const exitSignalSymbol = Symbol("CliExitSignal");
+const createCliExitSignal = (exitCode) => ({
+	[exitSignalSymbol]: true,
+	exitCode
+});
+const isCliExitSignal = (value) => typeof value === "object" && value !== null && exitSignalSymbol in value && value[exitSignalSymbol] === true;
+const fromUnknownError = (error) => {
+	if (error instanceof CliUsageError) return {
+		code: "USAGE_ERROR",
+		message: error.message,
+		details: error.details,
+		exitCode: EXIT_CODES.usage
+	};
+	if (error instanceof EndpointUnavailableError) return {
+		code: error.code,
+		message: error.message,
+		details: {
+			endpoint: error.endpoint,
+			status: error.status,
+			replacements: error.replacements
+		},
+		exitCode: EXIT_CODES.endpointUnavailable
+	};
+	if (error instanceof RateLimitError) return {
+		code: error.code,
+		message: error.message,
+		details: {
+			status: error.status,
+			url: error.url
+		},
+		exitCode: EXIT_CODES.rateLimited
+	};
+	if (error instanceof TransportError) return {
+		code: error.code,
+		message: error.message,
+		details: {
+			status: error.status,
+			url: error.url,
+			responseBody: error.responseBody
+		},
+		exitCode: EXIT_CODES.transport
+	};
+	if (error instanceof SchemaValidationError || error instanceof UnexpectedResponseError) return {
+		code: error.code,
+		message: error.message,
+		details: error instanceof SchemaValidationError ? {
+			endpoint: error.endpoint,
+			issues: error.issues
+		} : { endpoint: error.endpoint },
+		exitCode: EXIT_CODES.schemaDrift
+	};
+	if (error instanceof CommanderError) return {
+		code: "USAGE_ERROR",
+		message: error.message,
+		details: { commanderCode: error.code },
+		exitCode: EXIT_CODES.usage
+	};
+	if (error instanceof Error) return {
+		code: "UNKNOWN_ERROR",
+		message: error.message,
+		exitCode: EXIT_CODES.unknown
+	};
+	return {
+		code: "UNKNOWN_ERROR",
+		message: String(error),
+		exitCode: EXIT_CODES.unknown
+	};
+};
+const normalizeCliError = (error) => fromUnknownError(error);
+const isCommanderGracefulExit = (error) => error instanceof CommanderError && (error.code === "commander.helpDisplayed" || error.exitCode === 0);
+
+//#endregion
+//#region src/cli/output.ts
+const serializeJson = (value) => `${JSON.stringify(value)}\n`;
+const serializePretty = (value) => `${JSON.stringify(value, null, 2)}\n`;
+const writeSuccessEnvelope = (args) => {
+	if (args.mode === "pretty") {
+		args.io.stdout.write(serializePretty(args.envelope.data));
+		return;
+	}
+	args.io.stdout.write(serializeJson(args.envelope));
+};
+const writeErrorEnvelope = (args) => {
+	if (args.mode === "pretty") {
+		const body = [`[${args.error.code}] ${args.error.message}`, args.error.details ? `details: ${JSON.stringify(args.error.details, null, 2)}` : ""].filter((line) => line.length > 0).join("\n");
+		args.io.stderr.write(`${body}\n`);
+		return;
+	}
+	const payload = {
+		ok: false,
+		error: {
+			code: args.error.code,
+			message: args.error.message,
+			details: args.error.details,
+			exitCode: args.error.exitCode
+		}
+	};
+	args.io.stdout.write(serializeJson(payload));
+};
+const writeArbitraryOutput = (args) => {
+	if (args.mode === "pretty") {
+		args.io.stdout.write(serializePretty(args.payload));
+		return;
+	}
+	if (args.mode === "json") {
+		args.io.stdout.write(serializeJson(args.payload));
+		return;
+	}
+	if (Array.isArray(args.payload)) {
+		for (const item of args.payload) args.io.stdout.write(serializeJson(item));
+		return;
+	}
+	args.io.stdout.write(serializeJson(args.payload));
+};
+const spinnerFrames = [
+	"-",
+	"\\",
+	"|",
+	"/"
+];
+const createStderrSpinner = (args) => {
+	let frame = 0;
+	let message = "";
+	let timer;
+	const interactive = args.enabled && args.io.stderr.isTTY === true;
+	const render = () => {
+		if (!interactive) return;
+		const symbol = spinnerFrames[frame % spinnerFrames.length] ?? "-";
+		frame += 1;
+		args.io.stderr.write(`\r${symbol} ${message}`);
+	};
+	const clear = () => {
+		if (timer) {
+			clearInterval(timer);
+			timer = void 0;
+		}
+	};
+	return {
+		start(text) {
+			message = text;
+			if (!interactive) return;
+			render();
+			timer = setInterval(render, 80);
+		},
+		stop(text) {
+			clear();
+			if (!interactive) return;
+			args.io.stderr.write(`\rOK ${text}\n`);
+		},
+		fail(text) {
+			clear();
+			if (!interactive) return;
+			args.io.stderr.write(`\rERR ${text}\n`);
+		}
+	};
+};
+
+//#endregion
+//#region src/cli/manifest.ts
+const globalOptions = [
+	{
+		key: "output",
+		flags: "--output <mode>",
+		description: "Output mode: pretty, json, or jsonl.",
+		type: "string",
+		choices: [
+			"pretty",
+			"json",
+			"jsonl"
+		]
+	},
+	{
+		key: "raw",
+		flags: "--raw",
+		description: "Include raw upstream payload.",
+		type: "boolean"
+	},
+	{
+		key: "spinner",
+		flags: "--no-spinner",
+		description: "Disable the loading spinner.",
+		type: "boolean"
+	},
+	{
+		key: "hl",
+		flags: "--hl <locale>",
+		description: "Override language locale.",
+		type: "string"
+	},
+	{
+		key: "tz",
+		flags: "--tz <minutes>",
+		description: "Override timezone offset in minutes.",
+		type: "number"
+	},
+	{
+		key: "baseUrl",
+		flags: "--base-url <url>",
+		description: "Override Google Trends base URL.",
+		type: "string"
+	},
+	{
+		key: "timeoutMs",
+		flags: "--timeout-ms <ms>",
+		description: "HTTP timeout in milliseconds.",
+		type: "number"
+	},
+	{
+		key: "maxRetries",
+		flags: "--max-retries <n>",
+		description: "Maximum transport retries.",
+		type: "number"
+	},
+	{
+		key: "retryBaseDelayMs",
+		flags: "--retry-base-delay-ms <ms>",
+		description: "Retry base delay in milliseconds.",
+		type: "number"
+	},
+	{
+		key: "retryMaxDelayMs",
+		flags: "--retry-max-delay-ms <ms>",
+		description: "Retry max delay in milliseconds.",
+		type: "number"
+	},
+	{
+		key: "maxConcurrent",
+		flags: "--max-concurrent <n>",
+		description: "Maximum concurrent HTTP requests.",
+		type: "number"
+	},
+	{
+		key: "minDelayMs",
+		flags: "--min-delay-ms <ms>",
+		description: "Minimum delay between requests in milliseconds.",
+		type: "number"
+	},
+	{
+		key: "userAgent",
+		flags: "--user-agent <ua>",
+		description: "Custom user-agent header value.",
+		type: "string"
+	},
+	{
+		key: "input",
+		flags: "--input <json-or-file-or->",
+		description: "Use a JSON request payload string/file/stdin.",
+		type: "string"
+	}
+];
+const exploreLikeOptions = [
+	{
+		key: "geo",
+		flags: "--geo <geo>",
+		description: "Geo code (repeatable or comma-separated).",
+		type: "string-array"
+	},
+	{
+		key: "time",
+		flags: "--time <range>",
+		description: "Time range (for example: today 3-m).",
+		type: "string"
+	},
+	{
+		key: "category",
+		flags: "--category <id>",
+		description: "Category id.",
+		type: "number"
+	},
+	{
+		key: "property",
+		flags: "--property <property>",
+		description: "Google property filter.",
+		type: "string",
+		choices: [
+			"",
+			"images",
+			"news",
+			"youtube",
+			"froogle"
+		]
+	}
+];
+const toStringArray$1 = (value) => {
+	if (Array.isArray(value)) return value.filter((item) => typeof item === "string").flatMap((item) => item.split(",").map((part) => part.trim()).filter((part) => part.length > 0));
+	if (typeof value === "string") return value.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+	return [];
+};
+const toRawStringArray = (value) => {
+	if (Array.isArray(value)) return value.filter((item) => typeof item === "string");
+	if (typeof value === "string") return [value];
+	return [];
+};
+const readNumber = (value) => {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value !== "string") return;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : void 0;
+};
+const asRequest = (value) => value;
+const readString = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+const withGeo = (values) => {
+	if (values.length === 0) return;
+	if (values.length === 1) return values[0];
+	return values;
+};
+const parseArticleKey = (value) => {
+	const trimmed = value.trim();
+	if (trimmed.startsWith("[")) {
+		const parsed = JSON.parse(trimmed);
+		if (Array.isArray(parsed) && parsed.length === 3 && typeof parsed[0] === "number" && typeof parsed[1] === "string" && typeof parsed[2] === "string") return [
+			parsed[0],
+			parsed[1],
+			parsed[2]
+		];
+		throw new Error(`Invalid article key JSON: ${value}`);
+	}
+	const parts = trimmed.split(",").map((part) => part.trim());
+	if (parts.length !== 3) throw new Error(`Invalid article key: ${value}`);
+	const index = Number(parts[0]);
+	if (!Number.isFinite(index)) throw new TypeError(`Invalid article key index: ${parts[0]}`);
+	return [
+		index,
+		parts[1] ?? "",
+		parts[2] ?? ""
+	];
+};
+const buildExploreLikeRequest = (ctx) => {
+	return {
+		keywords: toStringArray$1(ctx.positionals[0]),
+		geo: withGeo(toStringArray$1(ctx.options.geo)),
+		time: readString(ctx.options.time),
+		category: readNumber(ctx.options.category),
+		property: readString(ctx.options.property)
+	};
+};
+const endpointManifest = [
+	{
+		id: "autocomplete",
+		path: ["autocomplete"],
+		summary: "Autocomplete topics by keyword.",
+		requestSchema: schemas.autocompleteRequestSchema,
+		options: [],
+		args: [{
+			label: "[keyword]",
+			description: "Keyword to autocomplete."
+		}],
+		buildRequest: (ctx) => ({ keyword: readString(ctx.positionals[0]) }),
+		invoke: (client, request, debug) => client.autocomplete(asRequest(request), debug)
+	},
+	{
+		id: "explore",
+		path: ["explore"],
+		summary: "Fetch explore widgets.",
+		requestSchema: schemas.exploreRequestSchema,
+		options: exploreLikeOptions,
+		args: [{
+			label: "[keywords...]",
+			description: "Keyword list."
+		}],
+		buildRequest: buildExploreLikeRequest,
+		invoke: (client, request, debug) => client.explore(asRequest(request), debug)
+	},
+	{
+		id: "interestOverTime",
+		path: ["interest-over-time"],
+		summary: "Fetch interest over time.",
+		requestSchema: schemas.interestOverTimeRequestSchema,
+		options: exploreLikeOptions,
+		args: [{
+			label: "[keywords...]",
+			description: "Keyword list."
+		}],
+		buildRequest: buildExploreLikeRequest,
+		invoke: (client, request, debug) => client.interestOverTime(asRequest(request), debug)
+	},
+	{
+		id: "interestByRegion",
+		path: ["interest-by-region"],
+		summary: "Fetch interest by region.",
+		requestSchema: schemas.interestByRegionRequestSchema,
+		options: [...exploreLikeOptions, {
+			key: "resolution",
+			flags: "--resolution <resolution>",
+			description: "Geo resolution (COUNTRY, REGION, CITY, DMA).",
+			type: "string",
+			choices: [
+				"COUNTRY",
+				"REGION",
+				"CITY",
+				"DMA"
+			]
+		}],
+		args: [{
+			label: "[keywords...]",
+			description: "Keyword list."
+		}],
+		buildRequest: (ctx) => ({
+			...buildExploreLikeRequest(ctx),
+			resolution: readString(ctx.options.resolution)
+		}),
+		invoke: (client, request, debug) => client.interestByRegion(asRequest(request), debug)
+	},
+	{
+		id: "relatedQueries",
+		path: ["related-queries"],
+		summary: "Fetch related queries.",
+		requestSchema: schemas.relatedQueriesRequestSchema,
+		options: exploreLikeOptions,
+		args: [{
+			label: "[keywords...]",
+			description: "Keyword list."
+		}],
+		buildRequest: buildExploreLikeRequest,
+		invoke: (client, request, debug) => client.relatedQueries(asRequest(request), debug)
+	},
+	{
+		id: "relatedTopics",
+		path: ["related-topics"],
+		summary: "Fetch related topics.",
+		requestSchema: schemas.relatedTopicsRequestSchema,
+		options: exploreLikeOptions,
+		args: [{
+			label: "[keywords...]",
+			description: "Keyword list."
+		}],
+		buildRequest: buildExploreLikeRequest,
+		invoke: (client, request, debug) => client.relatedTopics(asRequest(request), debug)
+	},
+	{
+		id: "dailyTrends",
+		path: ["daily-trends"],
+		summary: "Fetch daily trends (legacy-compatible endpoint).",
+		requestSchema: schemas.dailyTrendsRequestSchema,
+		options: [
+			{
+				key: "geo",
+				flags: "--geo <geo>",
+				description: "Geo code.",
+				type: "string"
+			},
+			{
+				key: "category",
+				flags: "--category <category>",
+				description: "Category id or name.",
+				type: "string"
+			},
+			{
+				key: "date",
+				flags: "--date <iso-date>",
+				description: "ISO date.",
+				type: "string"
+			},
+			{
+				key: "ns",
+				flags: "--ns <ns>",
+				description: "Namespace id.",
+				type: "number"
+			}
+		],
+		args: [],
+		buildRequest: (ctx) => ({
+			geo: readString(ctx.options.geo),
+			category: readString(ctx.options.category),
+			date: readString(ctx.options.date),
+			ns: readNumber(ctx.options.ns)
+		}),
+		invoke: (client, request, debug) => client.dailyTrends(asRequest(request), debug)
+	},
+	{
+		id: "realTimeTrends",
+		path: ["real-time-trends"],
+		summary: "Fetch realtime trends (legacy-compatible endpoint).",
+		requestSchema: schemas.realTimeTrendsRequestSchema,
+		options: [
+			{
+				key: "geo",
+				flags: "--geo <geo>",
+				description: "Geo code.",
+				type: "string"
+			},
+			{
+				key: "category",
+				flags: "--category <category>",
+				description: "Category id or name.",
+				type: "string"
+			},
+			{
+				key: "fi",
+				flags: "--fi <number>",
+				description: "FI parameter.",
+				type: "number"
+			},
+			{
+				key: "fs",
+				flags: "--fs <number>",
+				description: "FS parameter.",
+				type: "number"
+			},
+			{
+				key: "ri",
+				flags: "--ri <number>",
+				description: "RI parameter.",
+				type: "number"
+			},
+			{
+				key: "rs",
+				flags: "--rs <number>",
+				description: "RS parameter.",
+				type: "number"
+			},
+			{
+				key: "sort",
+				flags: "--sort <number>",
+				description: "Sort mode.",
+				type: "number"
+			}
+		],
+		args: [],
+		buildRequest: (ctx) => ({
+			geo: readString(ctx.options.geo),
+			category: readString(ctx.options.category),
+			fi: readNumber(ctx.options.fi),
+			fs: readNumber(ctx.options.fs),
+			ri: readNumber(ctx.options.ri),
+			rs: readNumber(ctx.options.rs),
+			sort: readNumber(ctx.options.sort)
+		}),
+		invoke: (client, request, debug) => client.realTimeTrends(asRequest(request), debug)
+	},
+	{
+		id: "trendingNow",
+		path: ["trending-now"],
+		summary: "Fetch trending now topics.",
+		requestSchema: schemas.trendingNowRequestSchema,
+		options: [
+			{
+				key: "geo",
+				flags: "--geo <geo>",
+				description: "Geo code.",
+				type: "string"
+			},
+			{
+				key: "language",
+				flags: "--language <language>",
+				description: "Language code.",
+				type: "string"
+			},
+			{
+				key: "hours",
+				flags: "--hours <hours>",
+				description: "Window in hours.",
+				type: "number"
+			}
+		],
+		args: [],
+		buildRequest: (ctx) => ({
+			geo: readString(ctx.options.geo),
+			language: readString(ctx.options.language),
+			hours: readNumber(ctx.options.hours)
+		}),
+		invoke: (client, request, debug) => client.trendingNow(asRequest(request), debug)
+	},
+	{
+		id: "trendingArticles",
+		path: ["trending-articles"],
+		summary: "Fetch trending articles from article keys.",
+		requestSchema: schemas.trendingArticlesRequestSchema,
+		options: [{
+			key: "articleKey",
+			flags: "--article-key <key>",
+			description: "Article key tuple (repeatable).",
+			type: "string-array-raw"
+		}, {
+			key: "articleCount",
+			flags: "--article-count <count>",
+			description: "Maximum article count.",
+			type: "number"
+		}],
+		args: [],
+		buildRequest: (ctx) => ({
+			articleKeys: toRawStringArray(ctx.options.articleKey).map(parseArticleKey),
+			articleCount: readNumber(ctx.options.articleCount)
+		}),
+		invoke: (client, request, debug) => client.trendingArticles(asRequest(request), debug)
+	},
+	{
+		id: "experimental.trendingNow",
+		path: ["experimental", "trending-now"],
+		summary: "Fetch experimental trending now topics.",
+		requestSchema: schemas.trendingNowRequestSchema,
+		options: [
+			{
+				key: "geo",
+				flags: "--geo <geo>",
+				description: "Geo code.",
+				type: "string"
+			},
+			{
+				key: "language",
+				flags: "--language <language>",
+				description: "Language code.",
+				type: "string"
+			},
+			{
+				key: "hours",
+				flags: "--hours <hours>",
+				description: "Window in hours.",
+				type: "number"
+			}
+		],
+		args: [],
+		buildRequest: (ctx) => ({
+			geo: readString(ctx.options.geo),
+			language: readString(ctx.options.language),
+			hours: readNumber(ctx.options.hours)
+		}),
+		invoke: (client, request, debug) => client.experimental.trendingNow(asRequest(request), debug)
+	},
+	{
+		id: "experimental.trendingArticles",
+		path: ["experimental", "trending-articles"],
+		summary: "Fetch experimental trending articles.",
+		requestSchema: schemas.trendingArticlesRequestSchema,
+		options: [{
+			key: "articleKey",
+			flags: "--article-key <key>",
+			description: "Article key tuple (repeatable).",
+			type: "string-array-raw"
+		}, {
+			key: "articleCount",
+			flags: "--article-count <count>",
+			description: "Maximum article count.",
+			type: "number"
+		}],
+		args: [],
+		buildRequest: (ctx) => ({
+			articleKeys: toRawStringArray(ctx.options.articleKey).map(parseArticleKey),
+			articleCount: readNumber(ctx.options.articleCount)
+		}),
+		invoke: (client, request, debug) => client.experimental.trendingArticles(asRequest(request), debug)
+	},
+	{
+		id: "experimental.geoPicker",
+		path: ["experimental", "geo-picker"],
+		summary: "Fetch experimental geo picker.",
+		requestSchema: pickerRequestSchema,
+		options: [],
+		args: [],
+		buildRequest: () => ({}),
+		invoke: (client, request, debug) => client.experimental.geoPicker(asRequest(request), debug)
+	},
+	{
+		id: "experimental.categoryPicker",
+		path: ["experimental", "category-picker"],
+		summary: "Fetch experimental category picker.",
+		requestSchema: pickerRequestSchema,
+		options: [],
+		args: [],
+		buildRequest: () => ({}),
+		invoke: (client, request, debug) => client.experimental.categoryPicker(asRequest(request), debug)
+	}
+];
+const platformCommandPaths = [
+	["config", "get"],
+	["config", "set"],
+	["config", "unset"],
+	["config", "list"],
+	["config", "reset"],
+	["wizard"],
+	["completion"],
+	["__complete"]
+];
+const commandPathsForCompletion = () => [...endpointManifest.map((item) => item.path), ...platformCommandPaths];
+const findEndpointDefinitionByPath = (path) => endpointManifest.find((item) => item.path.length === path.length && item.path.every((segment, index) => segment === path[index]));
+
+//#endregion
+//#region src/cli/completion.ts
+const parseFlagNames = (flags) => {
+	return flags.match(/--[a-z0-9-]+|-[a-z]/gi) ?? [];
+};
+const optionFlagsByPath = /* @__PURE__ */ new Map();
+const valueFlags = /* @__PURE__ */ new Set();
+for (const endpoint of endpointManifest) {
+	const key = endpoint.path.join(" ");
+	const names = [];
+	for (const option of [...globalOptions, ...endpoint.options]) {
+		const parsed = parseFlagNames(option.flags);
+		names.push(...parsed);
+		if (option.type !== "boolean") for (const flag of parsed) valueFlags.add(flag);
+	}
+	optionFlagsByPath.set(key, [...new Set(names)]);
+}
+optionFlagsByPath.set("config set", ["--json"]);
+valueFlags.add("--json");
+const visibleCommandPaths = commandPathsForCompletion().filter((path) => path[0] !== "__complete");
+const unique = (values) => [...new Set(values)];
+const extractCommandTokens = (words) => {
+	const commandTokens = [];
+	let skipValue = false;
+	for (const word of words) {
+		if (skipValue) {
+			skipValue = false;
+			continue;
+		}
+		if (word.startsWith("-")) {
+			const [flagName] = word.split("=", 2);
+			if (flagName && valueFlags.has(flagName) && !word.includes("=")) skipValue = true;
+			continue;
+		}
+		if (commandTokens.length < 2) commandTokens.push(word);
+	}
+	return commandTokens;
+};
+const flagsForPath = (path) => {
+	if (path.length === 0) return [];
+	const key = path.join(" ");
+	return optionFlagsByPath.get(key) ?? [];
+};
+const completeWords = (args) => {
+	const current = args.hasTrailingSpace ? "" : (args.words.at(-1) ?? "").trim();
+	const commandTokens = extractCommandTokens(args.hasTrailingSpace ? args.words : args.words.slice(0, -1));
+	if (current.startsWith("-")) return flagsForPath(commandTokens).filter((flag) => flag.startsWith(current)).toSorted();
+	const candidatePaths = visibleCommandPaths.filter((path) => commandTokens.every((segment, index) => path[index] === segment));
+	if (candidatePaths.length === 0) return visibleCommandPaths.map((path) => path[0] ?? "").filter((segment) => segment.startsWith(current)).toSorted();
+	const nextSegments = unique(candidatePaths.map((path) => path[commandTokens.length]).filter((segment) => typeof segment === "string")).filter((segment) => segment.startsWith(current)).toSorted();
+	if (nextSegments.length > 0) return nextSegments;
+	return flagsForPath(commandTokens).filter((flag) => flag.startsWith(current)).toSorted();
+};
+const scriptByShell = {
+	bash: (bin) => `_${bin}_complete() {
+  local IFS=$'\\n'
+  local line="$COMP_LINE"
+  local has_trailing_space=0
+  [[ "$line" == *" " ]] && has_trailing_space=1
+  COMPREPLY=( $( ${bin} __complete "$has_trailing_space" \${COMP_WORDS[@]:1} ) )
+}
+complete -F _${bin}_complete ${bin}
+`,
+	zsh: (bin) => `#compdef ${bin}
+_${bin}_complete() {
+  local -a suggestions
+  local line="$BUFFER"
+  local has_trailing_space=0
+  [[ "$line" == *" " ]] && has_trailing_space=1
+  suggestions=($(${bin} __complete "$has_trailing_space" \${words[@]:1}))
+  _describe 'values' suggestions
+}
+compdef _${bin}_complete ${bin}
+`,
+	fish: (bin) => `function __${bin}_complete
+  set -l line (commandline -cp)
+  set -l has_trailing_space 0
+  if string match -q '* ' -- "$line"
+    set has_trailing_space 1
+  end
+  ${bin} __complete $has_trailing_space (commandline -opc | tail -n +2)
+end
+complete -c ${bin} -f -a "(__${bin}_complete)"
+`
+};
+const renderCompletionScript = (shell, binaryName = "trendsearch") => {
+	if (shell === "bash" || shell === "zsh" || shell === "fish") {
+		const renderer = scriptByShell[shell];
+		return renderer(binaryName);
+	}
+};
+
+//#endregion
+//#region src/cli/wizard.ts
+const parseJsonInput$1 = (value) => {
+	try {
+		return JSON.parse(value);
+	} catch {
+		throw new Error("Request payload must be valid JSON.");
+	}
+};
+const runWizardPrompt = async () => {
+	intro("trendsearch wizard");
+	const endpoint = await select({
+		message: "Choose an endpoint",
+		options: endpointManifest.map((item) => ({
+			value: item.path.join(" "),
+			label: item.path.join(" "),
+			hint: item.summary
+		}))
+	});
+	if (isCancel(endpoint)) {
+		cancel("Wizard cancelled.");
+		return;
+	}
+	const endpointPath = String(endpoint).split(" ").map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+	const definition = findEndpointDefinitionByPath(endpointPath);
+	if (!definition) {
+		cancel("Unknown endpoint selection.");
+		return;
+	}
+	const requestText = await text({
+		message: "Request JSON payload",
+		placeholder: "{\"keywords\":[\"typescript\"],\"geo\":\"US\"}",
+		validate(value) {
+			if (typeof value !== "string") return "Request JSON is required.";
+			if (value.trim().length === 0) return "Request JSON is required.";
+			try {
+				parseJsonInput$1(value);
+			} catch {
+				return "Request must be valid JSON.";
+			}
+		}
+	});
+	if (isCancel(requestText)) {
+		cancel("Wizard cancelled.");
+		return;
+	}
+	if (typeof requestText !== "string") {
+		cancel("Request JSON must be a string.");
+		return;
+	}
+	const output = await select({
+		message: "Choose output mode",
+		options: [
+			{
+				value: "pretty",
+				label: "pretty"
+			},
+			{
+				value: "json",
+				label: "json"
+			},
+			{
+				value: "jsonl",
+				label: "jsonl"
+			}
+		]
+	});
+	if (isCancel(output)) {
+		cancel("Wizard cancelled.");
+		return;
+	}
+	const raw = await confirm({
+		message: "Include raw upstream response?",
+		initialValue: false
+	});
+	if (isCancel(raw)) {
+		cancel("Wizard cancelled.");
+		return;
+	}
+	outro(`Running ${definition.path.join(" ")}...`);
+	return {
+		endpointPath,
+		request: parseJsonInput$1(requestText),
+		output,
+		raw: Boolean(raw)
+	};
+};
+
+//#endregion
+//#region src/cli/program.ts
+const toStringArray = (value, previous) => [...previous, ...value.split(",").map((part) => part.trim()).filter((part) => part.length > 0)];
+const addOptionDefinition = (command, option) => {
+	if (option.type === "boolean") {
+		command.option(option.flags, option.description);
+		return;
+	}
+	const definition = new Option(option.flags, option.description);
+	if (option.choices && option.choices.length > 0) definition.choices([...option.choices]);
+	if (option.type === "number") definition.argParser(Number);
+	if (option.type === "string-array") {
+		definition.argParser((value, previous = []) => toStringArray(value, previous));
+		definition.default([]);
+	}
+	if (option.type === "string-array-raw") {
+		definition.argParser((value, previous = []) => [...previous, value]);
+		definition.default([]);
+	}
+	command.addOption(definition);
+};
+const addGlobalOptions = (command) => {
+	for (const option of globalOptions) addOptionDefinition(command, option);
+};
+const extractGlobalFlags = (options) => ({
+	output: options.output,
+	raw: options.raw,
+	spinner: options.spinner,
+	hl: options.hl,
+	tz: options.tz,
+	baseUrl: options.baseUrl,
+	timeoutMs: options.timeoutMs,
+	maxRetries: options.maxRetries,
+	retryBaseDelayMs: options.retryBaseDelayMs,
+	retryMaxDelayMs: options.retryMaxDelayMs,
+	maxConcurrent: options.maxConcurrent,
+	minDelayMs: options.minDelayMs,
+	userAgent: options.userAgent,
+	input: options.input
+});
+const readStdin = async (stdin) => new Promise((resolve, reject) => {
+	const chunks = [];
+	if ("setEncoding" in stdin && typeof stdin.setEncoding === "function") stdin.setEncoding("utf8");
+	stdin.on("data", (chunk) => {
+		chunks.push(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+	});
+	stdin.on("error", (error) => {
+		reject(error);
+	});
+	stdin.on("end", () => {
+		resolve(chunks.join(""));
+	});
+});
+const parseJsonInput = (text) => {
+	try {
+		return JSON.parse(text);
+	} catch {
+		throw new CliUsageError("Invalid JSON input payload.", { input: text });
+	}
+};
+const loadInputPayload = async (args) => {
+	if (args.input === "-") return parseJsonInput(await readStdin(args.stdin));
+	if (existsSync(args.input)) return parseJsonInput(await readFile(args.input, "utf8"));
+	return parseJsonInput(args.input);
+};
+const withCommonRequestDefaults = (args) => {
+	if (!(args.hl !== void 0 || args.tz !== void 0)) return args.request;
+	const base = args.request;
+	if (base === void 0 || base === null) {
+		const requestDefaults = {};
+		if (args.hl === void 0) {} else requestDefaults.hl = args.hl;
+		if (args.tz === void 0) {} else requestDefaults.tz = args.tz;
+		return requestDefaults;
+	}
+	if (typeof base !== "object" || Array.isArray(base)) return base;
+	const draft = { ...base };
+	if (args.hl !== void 0 && draft.hl === void 0) draft.hl = args.hl;
+	if (args.tz !== void 0 && draft.tz === void 0) draft.tz = args.tz;
+	return draft;
+};
+const toValidationIssues = (error) => error.issues.map((issue) => {
+	return `${issue.path.length > 0 ? issue.path.join(".") : "request"}: ${issue.message}`;
+});
+const parseRequestWithSchema = (args) => {
+	const parsed = args.definition.requestSchema.safeParse(args.request);
+	if (parsed.success) return parsed.data;
+	throw new CliUsageError("Request validation failed.", {
+		endpoint: args.definition.path.join(" "),
+		issues: toValidationIssues(parsed.error)
+	});
+};
+const createEndpointEnvelope = (args) => {
+	const endpointResult = args.result;
+	return {
+		ok: true,
+		endpoint: args.endpoint,
+		request: args.request,
+		data: endpointResult.data,
+		meta: {
+			command: args.command,
+			durationMs: args.durationMs,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			output: args.output
+		},
+		...args.includeRaw && endpointResult.raw !== void 0 ? { raw: endpointResult.raw } : {}
+	};
+};
+const executeEndpointCommand = async (args) => {
+	const resolvedGlobal = resolveGlobalOptions({
+		flags: extractGlobalFlags(args.options),
+		env: args.env,
+		store: args.configStore,
+		stdoutIsTty: args.io.stdout.isTTY === true
+	});
+	if (args.forcedOutput) resolvedGlobal.output = args.forcedOutput;
+	if (args.forcedRaw !== void 0) resolvedGlobal.raw = args.forcedRaw;
+	const requestWithCommonDefaults = withCommonRequestDefaults({
+		request: args.forcedRequest ?? (resolvedGlobal.input ? await loadInputPayload({
+			input: resolvedGlobal.input,
+			stdin: args.stdin
+		}) : args.definition.buildRequest({
+			positionals: args.positionals,
+			options: args.options
+		})),
+		hl: resolvedGlobal.hl,
+		tz: resolvedGlobal.tz
+	});
+	const request = parseRequestWithSchema({
+		definition: args.definition,
+		request: requestWithCommonDefaults
+	});
+	const spinner = createStderrSpinner({
+		io: args.io,
+		enabled: resolvedGlobal.spinner && resolvedGlobal.output === "pretty"
+	});
+	spinner.start(`Running ${args.definition.path.join(" ")}...`);
+	try {
+		const client = args.createClient(toCreateClientConfig(resolvedGlobal));
+		const start = Date.now();
+		const result = await args.definition.invoke(client, request, { debugRawResponse: resolvedGlobal.raw });
+		const durationMs = Date.now() - start;
+		spinner.stop(`Completed ${args.definition.path.join(" ")}.`);
+		writeSuccessEnvelope({
+			io: args.io,
+			mode: resolvedGlobal.output,
+			envelope: createEndpointEnvelope({
+				endpoint: args.definition.id,
+				request,
+				result,
+				command: args.definition.path.join(" "),
+				output: resolvedGlobal.output,
+				durationMs,
+				includeRaw: resolvedGlobal.raw
+			})
+		});
+	} catch (error) {
+		spinner.fail(`Failed ${args.definition.path.join(" ")}.`);
+		const normalized = normalizeCliError(error);
+		writeErrorEnvelope({
+			io: args.io,
+			mode: resolvedGlobal.output,
+			error: normalized
+		});
+		throw createCliExitSignal(normalized.exitCode);
+	}
+};
+const safeConfigAction = async (args) => {
+	const resolved = resolveGlobalOptions({
+		flags: { output: args.options.output },
+		env: args.env,
+		store: args.store,
+		stdoutIsTty: args.io.stdout.isTTY === true
+	});
+	try {
+		const payload = await args.task();
+		writeArbitraryOutput({
+			io: args.io,
+			mode: resolved.output,
+			payload
+		});
+	} catch (error) {
+		const normalized = normalizeCliError(error);
+		writeErrorEnvelope({
+			io: args.io,
+			mode: resolved.output,
+			error: normalized
+		});
+		throw createCliExitSignal(normalized.exitCode);
+	}
+};
+const configureConfigCommands = (args) => {
+	const configCommand = args.program.command("config").description("Manage persisted CLI defaults.");
+	configCommand.command("get <key>").description("Get a persisted config value.").option("--output <mode>", "Output mode (pretty|json|jsonl).", "pretty").action(async (...actionArgs) => {
+		const command = actionArgs.at(-1);
+		const options = command.opts();
+		const [key] = command.processedArgs;
+		await safeConfigAction({
+			io: args.io,
+			env: args.env,
+			store: args.store,
+			options,
+			task: () => ({
+				key,
+				value: args.store.get(key)
+			})
+		});
+	});
+	configCommand.command("set <key> <value>").description("Persist a config value.").option("--json", "Parse value as JSON.").option("--output <mode>", "Output mode (pretty|json|jsonl).", "pretty").action(async (...actionArgs) => {
+		const command = actionArgs.at(-1);
+		const options = command.opts();
+		const [key, value] = command.processedArgs;
+		await safeConfigAction({
+			io: args.io,
+			env: args.env,
+			store: args.store,
+			options,
+			task: () => {
+				const parsed = options.json ? parseJsonInput(value) : value;
+				args.store.set(key, parsed);
+				return {
+					key,
+					value: args.store.get(key)
+				};
+			}
+		});
+	});
+	configCommand.command("unset <key>").description("Delete a persisted config value.").option("--output <mode>", "Output mode (pretty|json|jsonl).", "pretty").action(async (...actionArgs) => {
+		const command = actionArgs.at(-1);
+		const options = command.opts();
+		const [key] = command.processedArgs;
+		await safeConfigAction({
+			io: args.io,
+			env: args.env,
+			store: args.store,
+			options,
+			task: () => {
+				args.store.delete(key);
+				return {
+					key,
+					removed: true
+				};
+			}
+		});
+	});
+	configCommand.command("list").description("List all persisted config values.").option("--output <mode>", "Output mode (pretty|json|jsonl).", "pretty").action(async (...actionArgs) => {
+		const options = actionArgs.at(-1).opts();
+		await safeConfigAction({
+			io: args.io,
+			env: args.env,
+			store: args.store,
+			options,
+			task: () => args.store.all()
+		});
+	});
+	configCommand.command("reset").description("Clear all persisted config values.").option("--output <mode>", "Output mode (pretty|json|jsonl).", "pretty").action(async (...actionArgs) => {
+		const options = actionArgs.at(-1).opts();
+		await safeConfigAction({
+			io: args.io,
+			env: args.env,
+			store: args.store,
+			options,
+			task: () => {
+				args.store.clear();
+				return { reset: true };
+			}
+		});
+	});
+};
+const configureEndpointCommands = (args) => {
+	const groupCommands = /* @__PURE__ */ new Map();
+	const getParentCommand = (path) => {
+		if (path.length === 0) return args.program;
+		let current = args.program;
+		for (const segment of path) {
+			const key = `${current.name()}:${segment}`;
+			const existing = groupCommands.get(key);
+			if (existing) {
+				current = existing;
+				continue;
+			}
+			const created = current.command(segment).description(`${segment} commands.`);
+			groupCommands.set(key, created);
+			current = created;
+		}
+		return current;
+	};
+	for (const definition of endpointManifest) {
+		const parentPath = definition.path.slice(0, -1);
+		const leaf = definition.path.at(-1);
+		if (!leaf) continue;
+		const command = getParentCommand(parentPath).command(leaf).description(definition.summary);
+		for (const arg of definition.args) command.argument(arg.label, arg.description);
+		for (const option of definition.options) addOptionDefinition(command, option);
+		addGlobalOptions(command);
+		command.action(async (...actionArgs) => {
+			const invokedCommand = actionArgs.at(-1);
+			const options = invokedCommand.opts();
+			const positionals = invokedCommand.processedArgs;
+			await executeEndpointCommand({
+				definition,
+				positionals,
+				options,
+				io: args.io,
+				env: args.env,
+				configStore: args.configStore,
+				stdin: args.stdin,
+				createClient: args.createClient
+			});
+		});
+	}
+};
+const configureWizardCommand = (args) => {
+	const wizardCommand = args.program.command("wizard").description("Run the interactive endpoint wizard.");
+	addGlobalOptions(wizardCommand);
+	wizardCommand.action(async (...actionArgs) => {
+		const options = actionArgs.at(-1).opts();
+		const selection = await runWizardPrompt();
+		if (!selection) return;
+		const definition = findEndpointDefinitionByPath(selection.endpointPath);
+		if (!definition) throw new CliUsageError("Unknown wizard endpoint selection.", { endpointPath: selection.endpointPath });
+		await executeEndpointCommand({
+			definition,
+			positionals: [],
+			options,
+			io: args.io,
+			env: args.env,
+			configStore: args.configStore,
+			stdin: args.stdin,
+			createClient: args.createClient,
+			forcedRequest: selection.request,
+			forcedOutput: selection.output,
+			forcedRaw: selection.raw
+		});
+	});
+};
+const configureCompletionCommands = (program, io) => {
+	program.command("completion <shell>").description("Generate shell completion script (bash|zsh|fish).").action((shell) => {
+		const script = renderCompletionScript(shell, "trendsearch");
+		if (!script) throw new CliUsageError("Unsupported shell for completion.", {
+			shell,
+			supported: [
+				"bash",
+				"zsh",
+				"fish"
+			]
+		});
+		io.stdout.write(script);
+	});
+	const completionHook = new Command("__complete").description("Internal shell completion hook.").argument("[hasTrailingSpace]").argument("[words...]").action((...actionArgs) => {
+		const [hasTrailingSpace, words] = actionArgs.at(-1).processedArgs;
+		const suggestions = completeWords({
+			words: words ?? [],
+			hasTrailingSpace: hasTrailingSpace === "1"
+		});
+		if (suggestions.length > 0) io.stdout.write(`${suggestions.join("\n")}\n`);
+	});
+	program.addCommand(completionHook, { hidden: true });
+};
+const createProgram = (options) => {
+	const createClient$1 = options.createClient ?? createClient;
+	const program = new Command();
+	program.name("trendsearch").description("Google Trends SDK CLI for stable + experimental endpoints.").version(options.env.npm_package_version ?? "0.0.0").showHelpAfterError();
+	configureEndpointCommands({
+		program,
+		io: options.io,
+		env: options.env,
+		configStore: options.configStore,
+		stdin: options.stdin,
+		createClient: createClient$1
+	});
+	configureConfigCommands({
+		program,
+		io: options.io,
+		env: options.env,
+		store: options.configStore
+	});
+	configureWizardCommand({
+		program,
+		io: options.io,
+		env: options.env,
+		configStore: options.configStore,
+		stdin: options.stdin,
+		createClient: createClient$1
+	});
+	configureCompletionCommands(program, options.io);
+	return program;
+};
+
+//#endregion
+//#region src/cli/main.ts
+const defaultIo = {
+	stdout: process.stdout,
+	stderr: process.stderr
+};
+const toDefaultOutputMode = (io) => io.stdout.isTTY === true ? "pretty" : "json";
+const runCli = async (options = {}) => {
+	const env = options.env ?? process.env;
+	const io = options.io ?? defaultIo;
+	const program = createProgram({
+		io,
+		env,
+		configStore: options.configStore ?? createCliConfigStore({ cwd: env.TRENDSEARCH_CONFIG_DIR }),
+		stdin: options.stdin ?? process.stdin,
+		createClient: options.createClient
+	});
+	program.configureOutput({
+		writeErr: (line) => {
+			io.stderr.write(line);
+		},
+		writeOut: (line) => {
+			io.stdout.write(line);
+		}
+	});
+	program.exitOverride();
+	try {
+		await program.parseAsync(options.argv ?? process.argv);
+		return EXIT_CODES.ok;
+	} catch (error) {
+		if (isCliExitSignal(error)) return error.exitCode;
+		if (isCommanderGracefulExit(error)) return EXIT_CODES.ok;
+		if (error instanceof CommanderError) return EXIT_CODES.usage;
+		const normalized = normalizeCliError(error);
+		writeErrorEnvelope({
+			io,
+			mode: toDefaultOutputMode(io),
+			error: normalized
+		});
+		return normalized.exitCode;
+	}
+};
+if (import.meta.main) {
+	const exitCode = await runCli();
+	process.exitCode = exitCode;
+}
+
+//#endregion
+export { runCli };