@victor-software-house/exa-cli 0.0.0

package/dist/cli.mjs

@@ -0,0 +1,1546 @@
+#!/usr/bin/env bun
+import "zod/compile";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { Database } from "bun:sqlite";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import * as z from "zod";
+import { createHash } from "node:crypto";
+import { match } from "ts-pattern";
+import { createColors } from "picocolors";
+import { object, or } from "@optique/core/constructs";
+import { message } from "@optique/core/message";
+import { multiple, optional, withDefault } from "@optique/core/modifiers";
+import { argument, command, constant, flag, negatableFlag, option } from "@optique/core/primitives";
+import { choice } from "@optique/core/valueparser";
+import { bindEnv, createEnvContext } from "@optique/env";
+import { path } from "@optique/run/valueparser";
+import { zod } from "@optique/zod";
+import { run } from "@optique/run";
+//#region src/env.ts
+const blankableSchema = z.string().trim().optional().transform((value) => {
+	if (value === void 0 || value === "") return;
+	return value;
+});
+const processEnvSchema = z.looseObject({
+	CI: blankableSchema,
+	EXA_API_KEY: blankableSchema,
+	EXA_API_URL: blankableSchema,
+	FORCE_COLOR: z.string().trim().optional(),
+	NO_COLOR: z.string().trim().optional(),
+	XDG_CACHE_HOME: blankableSchema
+});
+function parseEnv(source = process.env) {
+	return processEnvSchema.parse(source);
+}
+const env = parseEnv();
+function defaultCacheDir() {
+	if (env.XDG_CACHE_HOME !== void 0) return join(env.XDG_CACHE_HOME, "exa-cli");
+	return join(homedir(), ".cache", "exa-cli");
+}
+function defaultCachePath() {
+	return join(defaultCacheDir(), "cache.sqlite");
+}
+var CacheStore = class {
+	path;
+	#db;
+	constructor(path) {
+		mkdirSync(join(path, ".."), { recursive: true });
+		this.path = path;
+		this.#db = new Database(path);
+		this.#db.run("PRAGMA journal_mode = WAL");
+		this.#db.run(`
+			CREATE TABLE IF NOT EXISTS entries (
+				key TEXT PRIMARY KEY NOT NULL,
+				body TEXT NOT NULL,
+				created_at INTEGER NOT NULL
+			)
+		`);
+	}
+	get(key, ttlSeconds, now = Date.now()) {
+		const row = this.#db.query("SELECT key, body, created_at FROM entries WHERE key = ?").get(key);
+		if (row === null) return;
+		if (now - row.created_at > ttlSeconds * 1e3) {
+			this.#db.query("DELETE FROM entries WHERE key = ?").run(key);
+			return;
+		}
+		return {
+			key: row.key,
+			body: row.body,
+			createdAt: row.created_at
+		};
+	}
+	set(key, body, now = Date.now()) {
+		this.#db.query(`INSERT INTO entries (key, body, created_at)
+				 VALUES (?, ?, ?)
+				 ON CONFLICT(key) DO UPDATE SET body = excluded.body, created_at = excluded.created_at`).run(key, body, now);
+	}
+	count() {
+		const row = this.#db.query("SELECT COUNT(*) AS n FROM entries").get();
+		if (row === null) return 0;
+		return row.n;
+	}
+	close() {
+		this.#db.close();
+	}
+};
+//#endregion
+//#region src/generated/core/bodySerializer.gen.ts
+const jsonBodySerializer = { bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value) };
+Object.entries({
+	$body_: "body",
+	$headers_: "headers",
+	$path_: "path",
+	$query_: "query"
+});
+//#endregion
+//#region src/generated/core/serverSentEvents.gen.ts
+function createSseClient({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) {
+	let lastEventId;
+	const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const createStream = async function* () {
+		let retryDelay = sseDefaultRetryDelay ?? 3e3;
+		let attempt = 0;
+		const signal = options.signal ?? new AbortController().signal;
+		while (true) {
+			if (signal.aborted) break;
+			attempt++;
+			const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+			if (lastEventId !== void 0) headers.set("Last-Event-ID", lastEventId);
+			try {
+				const requestInit = {
+					redirect: "follow",
+					...options,
+					body: options.serializedBody,
+					headers,
+					signal
+				};
+				let request = new Request(url, requestInit);
+				if (onRequest) request = await onRequest(url, requestInit);
+				const response = await (options.fetch ?? globalThis.fetch)(request);
+				if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+				if (!response.body) throw new Error("No body in SSE response");
+				const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+				let buffer = "";
+				const abortHandler = () => {
+					try {
+						reader.cancel();
+					} catch {}
+				};
+				signal.addEventListener("abort", abortHandler);
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						buffer += value;
+						buffer = buffer.replace(/\r\n?/g, "\n");
+						const chunks = buffer.split("\n\n");
+						buffer = chunks.pop() ?? "";
+						for (const chunk of chunks) {
+							const lines = chunk.split("\n");
+							const dataLines = [];
+							let eventName;
+							for (const line of lines) if (line.startsWith("data:")) dataLines.push(line.replace(/^data:\s*/, ""));
+							else if (line.startsWith("event:")) eventName = line.replace(/^event:\s*/, "");
+							else if (line.startsWith("id:")) lastEventId = line.replace(/^id:\s*/, "");
+							else if (line.startsWith("retry:")) {
+								const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+								if (!Number.isNaN(parsed)) retryDelay = parsed;
+							}
+							let data;
+							let parsedJson = false;
+							if (dataLines.length) {
+								const rawData = dataLines.join("\n");
+								try {
+									data = JSON.parse(rawData);
+									parsedJson = true;
+								} catch {
+									data = rawData;
+								}
+							}
+							if (parsedJson) {
+								if (responseValidator) await responseValidator(data);
+								if (responseTransformer) data = await responseTransformer(data);
+							}
+							onSseEvent?.({
+								data,
+								event: eventName,
+								id: lastEventId,
+								retry: retryDelay
+							});
+							if (dataLines.length) yield data;
+						}
+					}
+				} finally {
+					signal.removeEventListener("abort", abortHandler);
+					reader.releaseLock();
+				}
+				break;
+			} catch (error) {
+				onSseError?.(error);
+				if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) break;
+				const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4);
+				await sleep(backoff);
+			}
+		}
+	};
+	return { stream: createStream() };
+}
+//#endregion
+//#region src/generated/core/pathSerializer.gen.ts
+const separatorArrayExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const separatorArrayNoExplode = (style) => {
+	switch (style) {
+		case "form": return ",";
+		case "pipeDelimited": return "|";
+		case "spaceDelimited": return "%20";
+		default: return ",";
+	}
+};
+const separatorObjectExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const serializeArrayParam = ({ allowReserved, explode, name, style, value }) => {
+	if (!explode) {
+		const joinedValues = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+		switch (style) {
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			case "simple": return joinedValues;
+			default: return `${name}=${joinedValues}`;
+		}
+	}
+	const separator = separatorArrayExplode(style);
+	const joinedValues = value.map((v) => {
+		if (style === "label" || style === "simple") return allowReserved ? v : encodeURIComponent(v);
+		return serializePrimitiveParam({
+			allowReserved,
+			name,
+			value: v
+		});
+	}).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+const serializePrimitiveParam = ({ allowReserved, name, value }) => {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "object") throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+	return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+const serializeObjectParam = ({ allowReserved, explode, name, style, value, valueOnly }) => {
+	if (value instanceof Date) return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+	if (style !== "deepObject" && !explode) {
+		let values = [];
+		Object.entries(value).forEach(([key, v]) => {
+			values = [
+				...values,
+				key,
+				allowReserved ? v : encodeURIComponent(v)
+			];
+		});
+		const joinedValues = values.join(",");
+		switch (style) {
+			case "form": return `${name}=${joinedValues}`;
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			default: return joinedValues;
+		}
+	}
+	const separator = separatorObjectExplode(style);
+	const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
+		allowReserved,
+		name: style === "deepObject" ? `${name}[${key}]` : key,
+		value: v
+	})).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+//#endregion
+//#region src/generated/core/utils.gen.ts
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+const defaultPathSerializer = ({ path, url: _url }) => {
+	let url = _url;
+	const matches = _url.match(PATH_PARAM_RE);
+	if (matches) for (const match of matches) {
+		let explode = false;
+		let name = match.substring(1, match.length - 1);
+		let style = "simple";
+		if (name.endsWith("*")) {
+			explode = true;
+			name = name.substring(0, name.length - 1);
+		}
+		if (name.startsWith(".")) {
+			name = name.substring(1);
+			style = "label";
+		} else if (name.startsWith(";")) {
+			name = name.substring(1);
+			style = "matrix";
+		}
+		const value = path[name];
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) {
+			url = url.replace(match, serializeArrayParam({
+				explode,
+				name,
+				style,
+				value
+			}));
+			continue;
+		}
+		if (typeof value === "object") {
+			url = url.replace(match, serializeObjectParam({
+				explode,
+				name,
+				style,
+				value,
+				valueOnly: true
+			}));
+			continue;
+		}
+		if (style === "matrix") {
+			url = url.replace(match, `;${serializePrimitiveParam({
+				name,
+				value
+			})}`);
+			continue;
+		}
+		const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
+		url = url.replace(match, replaceValue);
+	}
+	return url;
+};
+const getUrl = ({ baseUrl, path, query, querySerializer, url: _url }) => {
+	const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+	let url = (baseUrl ?? "") + pathUrl;
+	if (path) url = defaultPathSerializer({
+		path,
+		url
+	});
+	let search = query ? querySerializer(query) : "";
+	if (search.startsWith("?")) search = search.substring(1);
+	if (search) url += `?${search}`;
+	return url;
+};
+function getValidRequestBody(options) {
+	const hasBody = options.body !== void 0;
+	if (hasBody && options.bodySerializer) {
+		if ("serializedBody" in options) return options.serializedBody !== void 0 && options.serializedBody !== "" ? options.serializedBody : null;
+		return options.body !== "" ? options.body : null;
+	}
+	if (hasBody) return options.body;
+}
+//#endregion
+//#region src/generated/core/auth.gen.ts
+const getAuthToken = async (auth, callback) => {
+	const token = typeof callback === "function" ? await callback(auth) : callback;
+	if (!token) return;
+	if (auth.scheme === "bearer") return `Bearer ${token}`;
+	if (auth.scheme === "basic") return `Basic ${btoa(token)}`;
+	return token;
+};
+//#endregion
+//#region src/generated/client/utils.gen.ts
+const createQuerySerializer = ({ parameters = {}, ...args } = {}) => {
+	const querySerializer = (queryParams) => {
+		const search = [];
+		if (queryParams && typeof queryParams === "object") for (const name in queryParams) {
+			const value = queryParams[name];
+			if (value === void 0 || value === null) continue;
+			const options = parameters[name] || args;
+			if (Array.isArray(value)) {
+				const serializedArray = serializeArrayParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "form",
+					value,
+					...options.array
+				});
+				if (serializedArray) search.push(serializedArray);
+			} else if (typeof value === "object") {
+				const serializedObject = serializeObjectParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "deepObject",
+					value,
+					...options.object
+				});
+				if (serializedObject) search.push(serializedObject);
+			} else {
+				const serializedPrimitive = serializePrimitiveParam({
+					allowReserved: options.allowReserved,
+					name,
+					value
+				});
+				if (serializedPrimitive) search.push(serializedPrimitive);
+			}
+		}
+		return search.join("&");
+	};
+	return querySerializer;
+};
+/**
+* Infers parseAs value from provided Content-Type header.
+*/
+const getParseAs = (contentType) => {
+	if (!contentType) return "stream";
+	const cleanContent = contentType.split(";")[0]?.trim();
+	if (!cleanContent) return;
+	if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) return "json";
+	if (cleanContent === "multipart/form-data") return "formData";
+	if ([
+		"application/",
+		"audio/",
+		"image/",
+		"video/"
+	].some((type) => cleanContent.startsWith(type))) return "blob";
+	if (cleanContent.startsWith("text/")) return "text";
+};
+const checkForExistence = (options, name) => {
+	if (!name) return false;
+	if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) return true;
+	return false;
+};
+async function setAuthParams(options) {
+	for (const auth of options.security ?? []) {
+		if (checkForExistence(options, auth.name)) continue;
+		const token = await getAuthToken(auth, options.auth);
+		if (!token) continue;
+		const name = auth.name ?? "Authorization";
+		switch (auth.in) {
+			case "query":
+				if (!options.query) options.query = {};
+				options.query[name] = token;
+				break;
+			case "cookie":
+				options.headers.append("Cookie", `${name}=${token}`);
+				break;
+			default: options.headers.set(name, token);
+		}
+	}
+}
+const buildUrl = (options) => getUrl({
+	baseUrl: options.baseUrl,
+	path: options.path,
+	query: options.query,
+	querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+	url: options.url
+});
+const mergeConfigs = (a, b) => {
+	const config = {
+		...a,
+		...b
+	};
+	if (config.baseUrl?.endsWith("/")) config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+	config.headers = mergeHeaders(a.headers, b.headers);
+	return config;
+};
+const headersEntries = (headers) => {
+	const entries = [];
+	headers.forEach((value, key) => {
+		entries.push([key, value]);
+	});
+	return entries;
+};
+const mergeHeaders = (...headers) => {
+	const mergedHeaders = new Headers();
+	for (const header of headers) {
+		if (!header) continue;
+		const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+		for (const [key, value] of iterator) if (value === null) mergedHeaders.delete(key);
+		else if (Array.isArray(value)) for (const v of value) mergedHeaders.append(key, v);
+		else if (value !== void 0) mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
+	}
+	return mergedHeaders;
+};
+var Interceptors = class {
+	fns = [];
+	clear() {
+		this.fns = [];
+	}
+	eject(id) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) this.fns[index] = null;
+	}
+	exists(id) {
+		const index = this.getInterceptorIndex(id);
+		return Boolean(this.fns[index]);
+	}
+	getInterceptorIndex(id) {
+		if (typeof id === "number") return this.fns[id] ? id : -1;
+		return this.fns.indexOf(id);
+	}
+	update(id, fn) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) {
+			this.fns[index] = fn;
+			return id;
+		}
+		return false;
+	}
+	use(fn) {
+		this.fns.push(fn);
+		return this.fns.length - 1;
+	}
+};
+const createInterceptors = () => ({
+	error: new Interceptors(),
+	request: new Interceptors(),
+	response: new Interceptors()
+});
+const defaultQuerySerializer = createQuerySerializer({
+	allowReserved: false,
+	array: {
+		explode: true,
+		style: "form"
+	},
+	object: {
+		explode: true,
+		style: "deepObject"
+	}
+});
+const defaultHeaders = { "Content-Type": "application/json" };
+const createConfig = (override = {}) => ({
+	...jsonBodySerializer,
+	headers: defaultHeaders,
+	parseAs: "auto",
+	querySerializer: defaultQuerySerializer,
+	...override
+});
+//#endregion
+//#region src/generated/client/client.gen.ts
+const createClient = (config = {}) => {
+	let _config = mergeConfigs(createConfig(), config);
+	const getConfig = () => ({ ..._config });
+	const setConfig = (config) => {
+		_config = mergeConfigs(_config, config);
+		return getConfig();
+	};
+	const interceptors = createInterceptors();
+	const beforeRequest = async (options) => {
+		const opts = {
+			..._config,
+			...options,
+			fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+			headers: mergeHeaders(_config.headers, options.headers),
+			serializedBody: void 0
+		};
+		if (opts.security) await setAuthParams(opts);
+		if (opts.requestValidator) await opts.requestValidator(opts);
+		if (opts.body !== void 0 && opts.bodySerializer) opts.serializedBody = opts.bodySerializer(opts.body);
+		if (opts.body === void 0 || opts.serializedBody === "") opts.headers.delete("Content-Type");
+		const resolvedOpts = opts;
+		return {
+			opts: resolvedOpts,
+			url: buildUrl(resolvedOpts)
+		};
+	};
+	const request = async (options) => {
+		const throwOnError = options.throwOnError ?? _config.throwOnError;
+		const responseStyle = options.responseStyle ?? _config.responseStyle;
+		let request;
+		let response;
+		try {
+			const { opts, url } = await beforeRequest(options);
+			const requestInit = {
+				redirect: "follow",
+				...opts,
+				body: getValidRequestBody(opts)
+			};
+			request = new Request(url, requestInit);
+			for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+			const _fetch = opts.fetch;
+			response = await _fetch(request);
+			for (const fn of interceptors.response.fns) if (fn) response = await fn(response, request, opts);
+			const result = {
+				request,
+				response
+			};
+			if (response.ok) {
+				const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+				if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+					let emptyData;
+					switch (parseAs) {
+						case "arrayBuffer":
+						case "blob":
+						case "text":
+							emptyData = await response[parseAs]();
+							break;
+						case "formData":
+							emptyData = new FormData();
+							break;
+						case "stream":
+							emptyData = response.body;
+							break;
+						default: emptyData = {};
+					}
+					return opts.responseStyle === "data" ? emptyData : {
+						data: emptyData,
+						...result
+					};
+				}
+				let data;
+				switch (parseAs) {
+					case "arrayBuffer":
+					case "blob":
+					case "formData":
+					case "text":
+						data = await response[parseAs]();
+						break;
+					case "json": {
+						const text = await response.text();
+						data = text ? JSON.parse(text) : {};
+						break;
+					}
+					case "stream": return opts.responseStyle === "data" ? response.body : {
+						data: response.body,
+						...result
+					};
+				}
+				if (parseAs === "json") {
+					if (opts.responseValidator) await opts.responseValidator(data);
+					if (opts.responseTransformer) data = await opts.responseTransformer(data);
+				}
+				return opts.responseStyle === "data" ? data : {
+					data,
+					...result
+				};
+			}
+			const textError = await response.text();
+			let jsonError;
+			try {
+				jsonError = JSON.parse(textError);
+			} catch {}
+			throw jsonError ?? textError;
+		} catch (error) {
+			let finalError = error;
+			for (const fn of interceptors.error.fns) if (fn) finalError = await fn(finalError, response, request, options);
+			finalError = finalError || {};
+			if (throwOnError) throw finalError;
+			return responseStyle === "data" ? void 0 : {
+				error: finalError,
+				request,
+				response
+			};
+		}
+	};
+	const makeMethodFn = (method) => (options) => request({
+		...options,
+		method
+	});
+	const makeSseFn = (method) => async (options) => {
+		const { opts, url } = await beforeRequest(options);
+		return createSseClient({
+			...opts,
+			body: opts.body,
+			method,
+			onRequest: async (url, init) => {
+				let request = new Request(url, init);
+				for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+				return request;
+			},
+			serializedBody: getValidRequestBody(opts),
+			url
+		});
+	};
+	const _buildUrl = (options) => buildUrl({
+		..._config,
+		...options
+	});
+	return {
+		buildUrl: _buildUrl,
+		connect: makeMethodFn("CONNECT"),
+		delete: makeMethodFn("DELETE"),
+		get: makeMethodFn("GET"),
+		getConfig,
+		head: makeMethodFn("HEAD"),
+		interceptors,
+		options: makeMethodFn("OPTIONS"),
+		patch: makeMethodFn("PATCH"),
+		post: makeMethodFn("POST"),
+		put: makeMethodFn("PUT"),
+		request,
+		setConfig,
+		sse: {
+			connect: makeSseFn("CONNECT"),
+			delete: makeSseFn("DELETE"),
+			get: makeSseFn("GET"),
+			head: makeSseFn("HEAD"),
+			options: makeSseFn("OPTIONS"),
+			patch: makeSseFn("PATCH"),
+			post: makeSseFn("POST"),
+			put: makeSseFn("PUT"),
+			trace: makeSseFn("TRACE")
+		},
+		trace: makeMethodFn("TRACE")
+	};
+};
+//#endregion
+//#region src/generated/client.gen.ts
+const client = createClient(createConfig({
+	baseUrl: "https://api.exa.ai",
+	throwOnError: true
+}));
+//#endregion
+//#region src/generated/zod.gen.ts
+const zAnswerCitation = z.object({
+	id: z.string().optional(),
+	url: z.url().optional(),
+	title: z.string().optional(),
+	author: z.string().nullish(),
+	publishedDate: z.string().nullish(),
+	text: z.string().optional(),
+	image: z.url().optional(),
+	favicon: z.url().optional()
+});
+const zAnswerResult = z.object({
+	answer: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),
+	citations: z.array(zAnswerCitation).optional()
+});
+const zContentsRequest = z.object({
+	text: z.union([z.boolean(), z.object({
+		maxCharacters: z.int().optional(),
+		includeHtmlTags: z.boolean().optional().default(false),
+		verbosity: z.enum([
+			"compact",
+			"standard",
+			"full"
+		]).optional().default("compact"),
+		includeSections: z.array(z.enum([
+			"header",
+			"navigation",
+			"banner",
+			"body",
+			"sidebar",
+			"footer",
+			"metadata"
+		])).optional(),
+		excludeSections: z.array(z.enum([
+			"header",
+			"navigation",
+			"banner",
+			"body",
+			"sidebar",
+			"footer",
+			"metadata"
+		])).optional()
+	})]).optional(),
+	highlights: z.union([z.boolean(), z.object({
+		maxCharacters: z.int().gte(1).optional(),
+		numSentences: z.int().gte(1).optional(),
+		highlightsPerUrl: z.int().gte(1).optional(),
+		query: z.string().optional()
+	})]).optional(),
+	summary: z.object({
+		query: z.string().optional(),
+		schema: z.record(z.string(), z.unknown()).optional()
+	}).optional(),
+	livecrawl: z.enum([
+		"never",
+		"fallback",
+		"preferred",
+		"always"
+	]).optional(),
+	livecrawlTimeout: z.int().optional().default(1e4),
+	maxAgeHours: z.int().optional(),
+	subpages: z.int().optional().default(0),
+	subpageTarget: z.union([z.string(), z.array(z.string())]).optional(),
+	extras: z.object({
+		links: z.int().optional().default(0),
+		imageLinks: z.int().optional().default(0)
+	}).optional(),
+	context: z.union([z.boolean(), z.object({ maxCharacters: z.int().optional() })]).optional()
+});
+const zCommonRequest = z.object({
+	numResults: z.int().gte(1).lte(100).optional().default(10),
+	includeDomains: z.array(z.string()).optional(),
+	excludeDomains: z.array(z.string()).optional(),
+	startCrawlDate: z.iso.datetime().optional(),
+	endCrawlDate: z.iso.datetime().optional(),
+	startPublishedDate: z.iso.datetime().optional(),
+	endPublishedDate: z.iso.datetime().optional(),
+	includeText: z.array(z.string()).optional(),
+	excludeText: z.array(z.string()).optional(),
+	context: z.union([z.boolean(), z.object({ maxCharacters: z.int().optional() })]).optional(),
+	moderation: z.boolean().optional().default(false),
+	contents: zContentsRequest.optional()
+});
+/**
+* Company workforce information.
+*/
+const zEntityCompanyPropertiesWorkforce = z.object({ total: z.int().nullish() });
+/**
+* Company headquarters information.
+*/
+const zEntityCompanyPropertiesHeadquarters = z.object({
+	address: z.string().nullish(),
+	city: z.string().nullish(),
+	postalCode: z.string().nullish(),
+	country: z.string().nullish()
+});
+/**
+* Funding round information.
+*/
+const zEntityCompanyPropertiesFundingRound = z.object({
+	name: z.string().nullish(),
+	date: z.string().nullish(),
+	amount: z.int().nullish()
+});
+/**
+* Company financial information.
+*/
+const zEntityCompanyPropertiesFinancials = z.object({
+	revenueAnnual: z.int().nullish(),
+	fundingTotal: z.int().nullish(),
+	fundingLatestRound: zEntityCompanyPropertiesFundingRound.nullish()
+});
+/**
+* Company web traffic information.
+*/
+const zEntityCompanyPropertiesWebTraffic = z.object({ visitsMonthly: z.int().nullish() });
+/**
+* Structured properties for a company entity.
+*/
+const zEntityCompanyProperties = z.object({
+	name: z.string().nullish(),
+	foundedYear: z.int().nullish(),
+	description: z.string().nullish(),
+	workforce: zEntityCompanyPropertiesWorkforce.nullish(),
+	headquarters: zEntityCompanyPropertiesHeadquarters.nullish(),
+	financials: zEntityCompanyPropertiesFinancials.nullish(),
+	webTraffic: zEntityCompanyPropertiesWebTraffic.nullish()
+});
+/**
+* Date range for work history entries.
+*/
+const zEntityDateRange = z.object({
+	from: z.string().nullish(),
+	to: z.string().nullish()
+});
+/**
+* Reference to a company in work history.
+*/
+const zEntityPersonPropertiesCompanyRef = z.object({
+	id: z.string().nullish(),
+	name: z.string().nullish()
+});
+/**
+* A single work history entry for a person.
+*/
+const zEntityPersonPropertiesWorkHistoryEntry = z.object({
+	title: z.string().nullish(),
+	location: z.string().nullish(),
+	dates: zEntityDateRange.nullish(),
+	company: zEntityPersonPropertiesCompanyRef.nullish()
+});
+/**
+* Structured properties for a person entity.
+*/
+const zEntityPersonProperties = z.object({
+	name: z.string().nullish(),
+	location: z.string().nullish(),
+	workHistory: z.array(zEntityPersonPropertiesWorkHistoryEntry).optional()
+});
+/**
+* Structured entity data for a company.
+*/
+const zCompanyEntity = z.object({
+	id: z.string(),
+	type: z.enum(["company"]),
+	version: z.int(),
+	properties: zEntityCompanyProperties
+});
+/**
+* Structured entity data for a person.
+*/
+const zPersonEntity = z.object({
+	id: z.string(),
+	type: z.enum(["person"]),
+	version: z.int(),
+	properties: zEntityPersonProperties
+});
+/**
+* Structured entity data for company or person search results. Only returned for category=company or category=people searches.
+*/
+const zEntity = z.discriminatedUnion("type", [zCompanyEntity.extend({ type: z.literal("company") }), zPersonEntity.extend({ type: z.literal("person") })]);
+const zResultWithContent = z.object({
+	title: z.string().optional(),
+	url: z.url().optional(),
+	publishedDate: z.string().nullish(),
+	author: z.string().nullish(),
+	score: z.number().nullish(),
+	id: z.string().optional(),
+	image: z.url().optional(),
+	favicon: z.url().optional()
+}).and(z.lazy(() => z.object({
+	text: z.string().optional(),
+	highlights: z.array(z.string()).optional(),
+	highlightScores: z.array(z.number()).optional(),
+	summary: z.string().optional(),
+	subpages: z.array(z.lazy(() => zResultWithContent)).optional(),
+	extras: z.object({ links: z.array(z.string()).optional() }).optional(),
+	entities: z.array(zEntity).optional()
+})));
+const zCostDollars = z.object({
+	total: z.number().optional(),
+	breakDown: z.array(z.object({
+		search: z.number().optional(),
+		contents: z.number().optional(),
+		breakdown: z.object({
+			neuralSearch: z.number().optional(),
+			deepSearch: z.number().optional(),
+			contentText: z.number().optional(),
+			contentHighlight: z.number().optional(),
+			contentSummary: z.number().optional()
+		}).optional()
+	})).optional(),
+	perRequestPrices: z.object({
+		neuralSearch_1_25_results: z.number().optional(),
+		neuralSearch_26_100_results: z.number().optional(),
+		neuralSearch_100_plus_results: z.number().optional(),
+		deepSearch_1_25_results: z.number().optional(),
+		deepSearch_26_100_results: z.number().optional()
+	}).optional(),
+	perPagePrices: z.object({
+		contentText: z.number().optional(),
+		contentHighlight: z.number().optional(),
+		contentSummary: z.number().optional()
+	}).optional()
+});
+const zResearchTaskDto = z.object({
+	id: z.string(),
+	status: z.enum([
+		"running",
+		"completed",
+		"failed"
+	]),
+	instructions: z.string(),
+	schema: z.record(z.string(), z.unknown()).optional(),
+	data: z.record(z.string(), z.unknown()).optional(),
+	citations: z.record(z.string(), z.array(z.object({
+		id: z.string(),
+		url: z.string(),
+		title: z.string().optional(),
+		snippet: z.string()
+	}))).optional()
+});
+const zSearchBody = z.object({
+	query: z.string(),
+	additionalQueries: z.array(z.string()).optional(),
+	type: z.enum([
+		"neural",
+		"fast",
+		"auto",
+		"deep",
+		"deep-reasoning",
+		"instant"
+	]).optional().default("auto"),
+	outputSchema: z.record(z.string(), z.unknown()).optional(),
+	category: z.enum([
+		"company",
+		"research paper",
+		"news",
+		"pdf",
+		"github",
+		"personal site",
+		"people",
+		"financial report"
+	]).optional(),
+	userLocation: z.string().optional()
+}).and(zCommonRequest);
+/**
+* OK
+*/
+const zSearchResponse = z.object({
+	requestId: z.string().optional(),
+	results: z.array(zResultWithContent).optional(),
+	searchType: z.enum([
+		"neural",
+		"deep",
+		"deep-reasoning"
+	]).optional(),
+	context: z.string().optional(),
+	output: z.object({
+		content: z.union([z.string(), z.record(z.string(), z.unknown())]),
+		grounding: z.array(z.object({
+			field: z.string(),
+			citations: z.array(z.object({
+				url: z.string(),
+				title: z.string()
+			})),
+			confidence: z.enum([
+				"low",
+				"medium",
+				"high"
+			])
+		}))
+	}).optional(),
+	costDollars: zCostDollars.optional()
+});
+z.object({
+	url: z.string(),
+	excludeSourceDomain: z.boolean().optional()
+}).and(zCommonRequest);
+z.object({
+	requestId: z.string().optional(),
+	context: z.string().optional(),
+	results: z.array(zResultWithContent).optional(),
+	costDollars: zCostDollars.optional()
+});
+const zGetContentsBody = z.object({
+	urls: z.array(z.string()),
+	ids: z.array(z.string()).optional()
+}).and(zContentsRequest);
+/**
+* OK
+*/
+const zGetContentsResponse = z.object({
+	requestId: z.string().optional(),
+	results: z.array(zResultWithContent).optional(),
+	context: z.string().optional(),
+	statuses: z.array(z.object({
+		id: z.string().optional(),
+		status: z.enum(["success", "error"]).optional(),
+		error: z.object({
+			tag: z.enum([
+				"CRAWL_NOT_FOUND",
+				"CRAWL_TIMEOUT",
+				"CRAWL_LIVECRAWL_TIMEOUT",
+				"SOURCE_NOT_AVAILABLE",
+				"UNSUPPORTED_URL",
+				"CRAWL_UNKNOWN_ERROR"
+			]).optional(),
+			httpStatusCode: z.int().optional()
+		}).optional()
+	})).optional(),
+	costDollars: zCostDollars.optional()
+});
+const zAnswerBody = z.object({
+	query: z.string().min(1),
+	stream: z.boolean().optional().default(false),
+	text: z.boolean().optional().default(false),
+	outputSchema: z.object({
+		type: z.string().optional(),
+		properties: z.record(z.string(), z.unknown()).optional(),
+		required: z.array(z.string()).optional(),
+		description: z.string().optional(),
+		additionalProperties: z.boolean().optional().default(false)
+	}).optional()
+});
+/**
+* OK
+*/
+const zAnswerResponse = zAnswerResult.and(z.object({ costDollars: zCostDollars.optional() }));
+z.object({
+	cursor: z.string().min(1).optional(),
+	limit: z.number().gte(1).lte(200).optional().default(25)
+});
+z.object({
+	requestId: z.string().optional(),
+	data: z.array(zResearchTaskDto).optional(),
+	hasMore: z.boolean().optional(),
+	nextCursor: z.string().optional()
+});
+z.object({
+	instructions: z.string().max(4096),
+	model: z.enum(["exa-research", "exa-research-pro"]).optional().default("exa-research"),
+	output: z.object({
+		schema: z.unknown().optional(),
+		inferSchema: z.boolean().optional()
+	}).optional()
+});
+z.object({ id: z.string().optional() });
+z.object({ id: z.string() });
+//#endregion
+//#region src/generated/sdk.gen.ts
+/**
+* Search
+*
+* Perform a search with a Exa prompt-engineered query and retrieve a list of relevant results. Optionally get contents.
+*/
+const search = (options) => (options.client ?? client).post({
+	requestValidator: async (data) => await z.object({
+		body: zSearchBody,
+		path: z.never().optional(),
+		query: z.never().optional()
+	}).parseAsync(data),
+	responseValidator: async (data) => await zSearchResponse.parseAsync(data),
+	responseStyle: "data",
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}],
+	url: "/search",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Get Contents
+*/
+const getContents = (options) => (options.client ?? client).post({
+	requestValidator: async (data) => await z.object({
+		body: zGetContentsBody,
+		path: z.never().optional(),
+		query: z.never().optional()
+	}).parseAsync(data),
+	responseValidator: async (data) => await zGetContentsResponse.parseAsync(data),
+	responseStyle: "data",
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}],
+	url: "/contents",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Generate an answer from search results
+*
+* Performs a search based on the query and generates either a direct answer or a detailed summary with citations, depending on the query type.
+*
+*/
+const answer = (options) => (options.client ?? client).post({
+	requestValidator: async (data) => await z.object({
+		body: zAnswerBody,
+		path: z.never().optional(),
+		query: z.never().optional()
+	}).parseAsync(data),
+	responseValidator: async (data) => await zAnswerResponse.parseAsync(data),
+	responseStyle: "data",
+	security: [{
+		name: "x-api-key",
+		type: "apiKey"
+	}],
+	url: "/answer",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+//#endregion
+//#region src/http/client.ts
+function createExaClient(options) {
+	return createClient(createConfig({
+		auth: () => options.apiKey,
+		baseUrl: options.apiUrl,
+		throwOnError: true
+	}));
+}
+//#endregion
+//#region src/json.ts
+const jsonSchema = z.json();
+function parseJson(text) {
+	return jsonSchema.parse(JSON.parse(text));
+}
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/cache/key.ts
+function canonicalize(value) {
+	if (Array.isArray(value)) return value.map((item) => canonicalize(item));
+	if (isJsonObject(value)) return Object.fromEntries(Object.keys(value).toSorted().flatMap((key) => {
+		const item = value[key];
+		return item === void 0 ? [] : [[key, canonicalize(item)]];
+	}));
+	return value;
+}
+function cacheKey(identity) {
+	const canonical = canonicalize({
+		host: identity.host,
+		operation: identity.operation,
+		body: identity.body
+	});
+	return createHash("sha256").update(JSON.stringify(canonical)).digest("hex");
+}
+//#endregion
+//#region src/http/execute.ts
+async function executeCached(options) {
+	const key = cacheKey({
+		host: options.host,
+		operation: options.operation,
+		body: options.body
+	});
+	const cache = options.mode === "off" ? void 0 : options.cache;
+	if (cache !== void 0 && options.mode === "default") {
+		const hit = cache.get(key, options.ttlSeconds);
+		if (hit !== void 0) return {
+			payload: parseJson(hit.body),
+			cacheHit: true,
+			ageMs: Date.now() - hit.createdAt
+		};
+	}
+	const payload = await options.fetchBody();
+	if (cache !== void 0) cache.set(key, JSON.stringify(payload));
+	return {
+		payload,
+		cacheHit: false,
+		ageMs: void 0
+	};
+}
+function cacheMode(flags) {
+	return match(flags).returnType().with({ noCache: true }, () => "off").with({ refresh: true }, () => "refresh").otherwise(() => "default");
+}
+//#endregion
+//#region src/output/presenter.ts
+function resolveMode(options) {
+	return match(options).returnType().when((value) => value.json || value.output?.endsWith(".json") === true || !value.stdoutIsTTY, () => "json").when((value) => value.pretty, () => "pretty").otherwise(() => "text");
+}
+function colorEnabled(options) {
+	if (options.noColor || env.NO_COLOR !== void 0) return false;
+	if (options.forceColor || env.FORCE_COLOR !== void 0) return true;
+	return options.stdoutIsTTY;
+}
+function formatPayload(payload, mode, color) {
+	return match(mode).with("json", () => `${JSON.stringify(payload)}\n`).with("pretty", () => `${JSON.stringify(payload, null, 2)}\n`).with("text", () => `${formatText(payload, color)}\n`).exhaustive();
+}
+function formatCacheHit(ageMs) {
+	return `cache hit age=${formatAge(ageMs)}\n`;
+}
+function formatWrote(path) {
+	return `wrote ${path}\n`;
+}
+function formatTiming(elapsedMs) {
+	return `timing total=${Math.round(elapsedMs)}ms\n`;
+}
+function formatAge(ageMs) {
+	const seconds = Math.max(0, Math.round(ageMs / 1e3));
+	if (seconds < 60) return `${seconds}s`;
+	const minutes = Math.round(seconds / 60);
+	if (minutes < 60) return `${minutes}m`;
+	return `${Math.round(minutes / 60)}h`;
+}
+function formatText(payload, color) {
+	const pc = createColors(color);
+	if (!isJsonObject(payload)) return JSON.stringify(payload, null, 2);
+	return match(payload).when((value) => isStringField(value["answer"]) || Array.isArray(value["citations"]), (value) => formatAnswer(value, pc)).when((value) => Array.isArray(value["results"]), (value) => formatResults(asJsonArray(value["results"]), pc)).otherwise((value) => JSON.stringify(value, null, 2));
+}
+function formatResults(results, pc) {
+	const lines = [];
+	for (const result of results) {
+		if (!isJsonObject(result)) continue;
+		const url = result["url"];
+		if (isStringField(url)) lines.push(pc.underline(url));
+		const title = result["title"];
+		if (isStringField(title)) lines.push(`  ${pc.bold(title)}`);
+	}
+	return lines.join("\n");
+}
+function formatAnswer(payload, pc) {
+	const lines = [];
+	const answer = payload["answer"];
+	if (isStringField(answer)) lines.push(answer);
+	else if (answer !== void 0 && answer !== null) lines.push(JSON.stringify(answer, null, 2));
+	const citations = payload["citations"];
+	if (Array.isArray(citations)) for (const citation of citations) {
+		if (!isJsonObject(citation)) continue;
+		const url = citation["url"];
+		if (isStringField(url)) lines.push(pc.underline(url));
+	}
+	return lines.join("\n");
+}
+function isStringField(value) {
+	return z.string().trim().safeParse(value).success;
+}
+function asJsonArray(value) {
+	return Array.isArray(value) ? value : [];
+}
+//#endregion
+//#region src/parser.ts
+const querySchema = z.string().trim().min(1, { error: "Query must not be empty." }).meta({ description: "Exa query" });
+const countSchema = z.coerce.number().positive({ error: "Expected a positive number." }).meta({ description: "Positive count" });
+function jsonBody(schema) {
+	return z.string().trim().transform((raw, ctx) => {
+		try {
+			return schema.parse(parseJson(raw));
+		} catch {
+			ctx.addIssue({
+				code: "custom",
+				message: "Expected JSON."
+			});
+			return z.NEVER;
+		}
+	});
+}
+const envContext = createEnvContext();
+const apiKeyParser = bindEnv(optional(option("-k", "--api-key", zod(querySchema, { placeholder: "key" }), { description: message`Exa API key. Falls back to EXA_API_KEY.` })), {
+	context: envContext,
+	key: "EXA_API_KEY",
+	parser: zod(querySchema, { placeholder: "key" })
+});
+const apiUrlParser = bindEnv(optional(option("--api-url", zod(querySchema, { placeholder: "https://api.exa.ai" }), { description: message`Exa API base URL.` })), {
+	context: envContext,
+	key: "EXA_API_URL",
+	parser: zod(querySchema, { placeholder: "https://api.exa.ai" }),
+	default: "https://api.exa.ai"
+});
+function globalFields() {
+	return {
+		apiKey: apiKeyParser,
+		apiUrl: apiUrlParser,
+		json: withDefault(flag("--json", { description: message`Write compact JSON to stdout.` }), false),
+		pretty: withDefault(flag("--pretty", { description: message`Write indented JSON to stdout.` }), false),
+		output: optional(option("-o", "--output", path({
+			allowCreate: true,
+			metavar: "FILE"
+		}), { description: message`Write the payload to a file instead of stdout.` })),
+		timing: withDefault(flag("--timing", { description: message`Print elapsed time on stderr.` }), false),
+		refresh: withDefault(flag("--refresh", { description: message`Ignore cache reads and overwrite the stored response.` }), false),
+		noCache: withDefault(flag("--no-cache", { description: message`Skip cache reads and writes.` }), false),
+		ttl: optional(option("--ttl", zod(countSchema, { placeholder: 86400 }), { description: message`Cache TTL in seconds. Default 86400.` })),
+		envelope: withDefault(flag("--envelope", { description: message`Wrap JSON output with cache metadata.` }), false),
+		color: optional(negatableFlag({
+			positive: "--color",
+			negative: "--no-color"
+		}, { description: message`Force or disable color.` }))
+	};
+}
+const searchCommand = command("search", object({
+	command: constant("search"),
+	...globalFields(),
+	query: optional(argument(zod(querySchema, { placeholder: "query" }), { description: message`Search query. Omit when using --request.` })),
+	request: optional(option("--request", zod(jsonBody(zSearchBody), {
+		metavar: "JSON",
+		placeholder: zSearchBody.parse({ query: "query" })
+	}), { description: message`JSON search body for /search.` })),
+	numResults: optional(option("-n", "--num-results", zod(countSchema, { placeholder: 10 }), { description: message`Number of results.` })),
+	type: optional(option("--type", choice([
+		"neural",
+		"fast",
+		"auto",
+		"deep",
+		"deep-reasoning",
+		"instant"
+	]), { description: message`Search type.` })),
+	includeDomain: multiple(option("--include-domain", zod(querySchema, { placeholder: "exa.ai" }), { description: message`Restrict results to this domain. Repeatable.` }))
+}));
+const contentsCommand = command("contents", object({
+	command: constant("contents"),
+	...globalFields(),
+	urls: multiple(argument(zod(querySchema, { placeholder: "URL" }), { description: message`Page URL. Repeatable. Omit when using --request.` })),
+	request: optional(option("--request", zod(jsonBody(zGetContentsBody), {
+		metavar: "JSON",
+		placeholder: zGetContentsBody.parse({ urls: ["https://exa.ai"] })
+	}), { description: message`JSON contents body for /contents.` })),
+	maxAgeHours: optional(option("--max-age-hours", zod(countSchema, { placeholder: 24 }), { description: message`Provider contents freshness window.` }))
+}));
+const answerCommand = command("answer", object({
+	command: constant("answer"),
+	...globalFields(),
+	query: optional(argument(zod(querySchema, { placeholder: "query" }), { description: message`Question to answer. Omit when using --request.` })),
+	request: optional(option("--request", zod(jsonBody(zAnswerBody), {
+		metavar: "JSON",
+		placeholder: zAnswerBody.parse({ query: "query" })
+	}), { description: message`JSON answer body for /answer.` })),
+	text: withDefault(flag("--text", { description: message`Include full text on citations.` }), false)
+}));
+const doctorCommand = command("doctor", object({
+	command: constant("doctor"),
+	...globalFields()
+}));
+const parser = or(searchCommand, contentsCommand, answerCommand, doctorCommand);
+const version = "0.0.0";
+//#endregion
+//#region src/app.ts
+async function runAppParse(args) {
+	const options = {
+		programName: "exa",
+		brief: message`CLI for Exa search, contents, and answer.`,
+		help: "both",
+		version,
+		completion: "both",
+		contexts: [envContext]
+	};
+	if (args === void 0) return await run(parser, options);
+	return await run(parser, {
+		...options,
+		args
+	});
+}
+async function runApp(args) {
+	await dispatch(await runAppParse(args));
+}
+async function dispatch(parsed) {
+	await match(parsed).with({ command: "doctor" }, (value) => {
+		runDoctor(value);
+		return Promise.resolve();
+	}).with({ command: "search" }, runSearch).with({ command: "contents" }, runContents).with({ command: "answer" }, runAnswer).exhaustive();
+}
+function runDoctor(parsed) {
+	const cache = new CacheStore(defaultCachePath());
+	const lines = [
+		`api-key: ${parsed.apiKey === void 0 || parsed.apiKey === "" ? "missing" : "set"}`,
+		`api-url: ${parsed.apiUrl ?? "https://api.exa.ai"}`,
+		`cache: ${cache.path}`,
+		`entries: ${String(cache.count())}`
+	];
+	cache.close();
+	process.stdout.write(`${lines.join("\n")}\n`);
+}
+async function runSearch(parsed) {
+	const started = Date.now();
+	const body = parsed.request !== void 0 ? zSearchBody.parse(parsed.request) : flagSearchBody(parsed);
+	await runOperation({
+		parsed,
+		operation: "search",
+		body,
+		started,
+		fetchBody: async (client) => parseJson(JSON.stringify(await search({
+			client,
+			body
+		})))
+	});
+}
+async function runContents(parsed) {
+	const started = Date.now();
+	const body = parsed.request !== void 0 ? zGetContentsBody.parse(parsed.request) : flagContentsBody(parsed);
+	await runOperation({
+		parsed,
+		operation: "contents",
+		body,
+		started,
+		fetchBody: async (client) => parseJson(JSON.stringify(await getContents({
+			client,
+			body
+		})))
+	});
+}
+async function runAnswer(parsed) {
+	const started = Date.now();
+	const body = parsed.request !== void 0 ? zAnswerBody.parse(parsed.request) : flagAnswerBody(parsed);
+	await runOperation({
+		parsed,
+		operation: "answer",
+		body,
+		started,
+		fetchBody: async (client) => parseJson(JSON.stringify(await answer({
+			client,
+			body
+		})))
+	});
+}
+async function runOperation(options) {
+	const apiKey = requireApiKey(options.parsed.apiKey);
+	const apiUrl = options.parsed.apiUrl ?? "https://api.exa.ai";
+	const host = new URL(apiUrl).host;
+	const ttlSeconds = options.parsed.ttl ?? 86400;
+	const mode = cacheMode({
+		refresh: options.parsed.refresh,
+		noCache: options.parsed.noCache
+	});
+	const cache = mode === "off" ? void 0 : new CacheStore(defaultCachePath());
+	const client = createExaClient({
+		apiKey,
+		apiUrl
+	});
+	try {
+		const executed = await executeCached({
+			host,
+			operation: options.operation,
+			body: parseJson(JSON.stringify(options.body)),
+			cache,
+			mode,
+			ttlSeconds,
+			fetchBody: () => options.fetchBody(client)
+		});
+		writeOutput(options.parsed, executed.payload, executed.cacheHit, executed.ageMs, options.started);
+	} catch (error) {
+		fail(`${options.operation} failed: ${errorMessageSchema.parse(error)}`);
+	} finally {
+		cache?.close();
+	}
+}
+function writeOutput(parsed, payload, cacheHit, ageMs, started) {
+	const stdoutIsTTY = process.stdout.isTTY ?? false;
+	const noColor = parsed.color === false;
+	const forceColor = parsed.color === true;
+	const presenter = {
+		json: parsed.json,
+		pretty: parsed.pretty,
+		output: parsed.output,
+		stdoutIsTTY,
+		noColor,
+		forceColor
+	};
+	const mode = resolveMode(presenter);
+	const color = colorEnabled(presenter);
+	const renderedPayload = parsed.envelope && (mode === "json" || mode === "pretty") ? {
+		data: payload,
+		cache: {
+			hit: cacheHit,
+			ageMs: ageMs ?? null
+		}
+	} : payload;
+	const text = formatPayload(parseJson(JSON.stringify(renderedPayload)), mode, color && mode === "text");
+	if (parsed.output !== void 0) {
+		writeFileSync(parsed.output, text);
+		process.stderr.write(formatWrote(parsed.output));
+	} else process.stdout.write(text);
+	if (cacheHit && ageMs !== void 0 && !parsed.envelope) process.stderr.write(formatCacheHit(ageMs));
+	if (parsed.timing) process.stderr.write(formatTiming(Date.now() - started));
+}
+function flagSearchBody(parsed) {
+	if (parsed.query === void 0) fail("search requires a query or --request.");
+	const body = {
+		query: parsed.query,
+		contents: { highlights: true }
+	};
+	if (parsed.numResults !== void 0) body.numResults = parsed.numResults;
+	if (parsed.type !== void 0) body.type = parsed.type;
+	if (parsed.includeDomain.length > 0) body.includeDomains = [...parsed.includeDomain];
+	return body;
+}
+function flagContentsBody(parsed) {
+	if (parsed.urls.length === 0) fail("contents requires at least one URL or --request.");
+	const body = {
+		urls: [...parsed.urls],
+		highlights: true
+	};
+	if (parsed.maxAgeHours !== void 0) body.maxAgeHours = parsed.maxAgeHours;
+	return body;
+}
+function flagAnswerBody(parsed) {
+	if (parsed.query === void 0) fail("answer requires a query or --request.");
+	return {
+		query: parsed.query,
+		text: parsed.text
+	};
+}
+function requireApiKey(apiKey) {
+	if (apiKey === void 0 || apiKey === "") fail("Missing API key. Set EXA_API_KEY or pass --api-key.");
+	return apiKey;
+}
+const errorMessageSchema = z.union([
+	z.string().trim(),
+	z.instanceof(Error).transform((error) => error.message),
+	z.json().transform((value) => JSON.stringify(value))
+]);
+function fail(messageText) {
+	process.stderr.write(`${messageText}\n`);
+	process.exit(1);
+}
+//#endregion
+//#region src/cli.ts
+await runApp();
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.mjs.map