wity-cli 0.1.0

package/dist/send-CGXuVi9Z.mjs

@@ -0,0 +1,1052 @@
+import { format, stripVTControlCharacters, styleText } from "node:util";
+import { lstat, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { z } from "zod";
+//#region node_modules/wity-sdk/dist/index.mjs
+/** Base class for all SDK errors. Also thrown for setup problems, like a missing key. */
+var WityError = class extends Error {
+	name = "WityError";
+};
+const MOVED_HINT = "The API address may have changed. Set WITY_BASE_URL to the new address, or update the wity package.";
+/** Extra advice added to the message for some statuses. */
+const hintFor = (status) => {
+	if (status >= 300 && status < 400) return `The API answered with a redirect, which this SDK never follows. ${MOVED_HINT}`;
+	if (status === 401) return "Check WITY_API_KEY.";
+	if (status === 402) return "The account has no balance left.";
+	if (status === 404) return MOVED_HINT;
+};
+const MAX_TEXT_IN_MESSAGE = 200;
+/** Turn a list of validation errors (`[{loc, msg}, ...]`) into "field: problem; field: problem". */
+const describeList = (items) => {
+	const parts = items.flatMap((item) => {
+		if (typeof item !== "object" || item === null) return [];
+		const { loc, msg } = item;
+		if (typeof msg !== "string") return [];
+		const where = Array.isArray(loc) ? loc.filter((part) => part !== "body").join(".") : "";
+		return [where ? `${where}: ${msg}` : msg];
+	});
+	return parts.length > 0 ? parts.join("; ") : void 0;
+};
+/**
+* Read the message out of an error body.
+* Wity uses `{"error": "..."}` on some routes and `{"detail": "..."}` on others.
+*/
+const messageFrom = (body) => {
+	if (typeof body === "string") {
+		const text = body.trim();
+		if (text.startsWith("<")) return "the server sent an HTML error page";
+		return text.length > MAX_TEXT_IN_MESSAGE ? `${text.slice(0, MAX_TEXT_IN_MESSAGE)}…` : text || void 0;
+	}
+	if (typeof body !== "object" || body === null) return void 0;
+	const { error, detail, message } = body;
+	for (const value of [
+		error,
+		detail,
+		message
+	]) {
+		if (typeof value === "string") return value;
+		if (Array.isArray(value)) return describeList(value);
+		if (typeof value === "object" && value !== null) {
+			const inner = value.message;
+			if (typeof inner === "string") return inner;
+		}
+	}
+};
+/** The id the server gave this request. Quote it when reporting a problem. */
+const requestIdFrom = (headers) => headers.get("x-request-id") ?? headers.get("x-railway-request-id") ?? void 0;
+/** The API answered with an error status. */
+var APIError = class APIError extends WityError {
+	name = "APIError";
+	/** HTTP status code, for example 400. */
+	status;
+	/** The response body: parsed JSON, text, or `undefined` if empty. */
+	body;
+	/** The response headers, for example `Retry-After`. */
+	headers;
+	/** The server's id for this request, if it sent one. */
+	requestId;
+	/** `note` is extra context from the SDK, added to the end of the message. */
+	constructor(status, body, headers, note) {
+		const detail = messageFrom(body)?.replace(/\.+$/, "");
+		const head = detail ? `${status} ${detail}` : String(status);
+		const extra = [hintFor(status), note].filter(Boolean).join(" ");
+		super(extra ? `${head}. ${extra}` : head);
+		this.status = status;
+		this.body = body;
+		this.headers = headers;
+		this.requestId = requestIdFrom(headers);
+	}
+	/** Pick the error class that matches the status. */
+	static fromResponse(status, body, headers, note) {
+		if (status === 400) return new BadRequestError(status, body, headers, note);
+		if (status === 401) return new AuthenticationError(status, body, headers, note);
+		if (status === 402) return new InsufficientBalanceError(status, body, headers, note);
+		if (status === 429) return new RateLimitError(status, body, headers, note);
+		if (status >= 500) return new InternalServerError(status, body, headers, note);
+		return new APIError(status, body, headers, note);
+	}
+};
+/** 400: the request is wrong. The message says which part. */
+var BadRequestError = class extends APIError {
+	name = "BadRequestError";
+};
+/** 401: the API key is missing or wrong. */
+var AuthenticationError = class extends APIError {
+	name = "AuthenticationError";
+};
+/** 402: the account has no balance left. */
+var InsufficientBalanceError = class extends APIError {
+	name = "InsufficientBalanceError";
+};
+/** 429: too many requests. Thrown after the SDK's retries run out. */
+var RateLimitError = class extends APIError {
+	name = "RateLimitError";
+};
+/** 5xx: a problem on Wity's side. Thrown after the SDK's retries run out. */
+var InternalServerError = class extends APIError {
+	name = "InternalServerError";
+};
+/** The API couldn't be reached, or the connection broke while reading the answer. */
+var APIConnectionError = class extends WityError {
+	name = "APIConnectionError";
+};
+/** The API didn't answer within the timeout. */
+var APITimeoutError = class extends WityError {
+	name = "APITimeoutError";
+};
+/** You cancelled the request with its `signal`. */
+var APIUserAbortError = class extends WityError {
+	name = "APIUserAbortError";
+};
+const LOG_LEVELS = [
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"off"
+];
+const DEFAULT_LOG_LEVEL = "warn";
+/** Check a level from the `logLevel` option or WITY_LOG_LEVEL. */
+const parseLogLevel = (value, source) => {
+	const level = value.trim().toLowerCase();
+	if (LOG_LEVELS.includes(level)) return level;
+	throw new WityError(`${source} must be one of: ${LOG_LEVELS.join(", ")}.`);
+};
+const PREFIX = "[wity]";
+/** The default logger: the console, with a `[wity]` prefix. */
+const consoleLogger = {
+	debug: (message, ...args) => console.debug(`${PREFIX} ${message}`, ...args),
+	info: (message, ...args) => console.info(`${PREFIX} ${message}`, ...args),
+	warn: (message, ...args) => console.warn(`${PREFIX} ${message}`, ...args),
+	error: (message, ...args) => console.error(`${PREFIX} ${message}`, ...args)
+};
+const RANK = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3,
+	off: 4
+};
+const drop = () => {};
+/** Pass on only messages at `level` or above. */
+const withLevel = (sink, level) => {
+	const on = (at) => RANK[at] >= RANK[level];
+	return {
+		debug: on("debug") ? (message, ...args) => sink.debug(message, ...args) : drop,
+		info: on("info") ? (message, ...args) => sink.info(message, ...args) : drop,
+		warn: on("warn") ? (message, ...args) => sink.warn(message, ...args) : drop,
+		error: on("error") ? (message, ...args) => sink.error(message, ...args) : drop
+	};
+};
+/** Statuses worth retrying: 408 (timeout), 429 (too many requests) and 5xx (Wity's side). */
+const shouldRetryStatus = (status) => status === 408 || status === 429 || status >= 500;
+/** Read `Retry-After` as milliseconds. It can be seconds ("1") or a date. */
+const retryAfterMs = (headers) => {
+	const raw = headers.get("retry-after");
+	if (raw === null) return void 0;
+	const seconds = Number(raw);
+	if (raw.trim() !== "" && Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+	const date = Date.parse(raw);
+	return Number.isNaN(date) ? void 0 : Math.max(0, date - Date.now());
+};
+/** Wait 0.5 s, then 1 s, 2 s... up to 8 s. The random part stops many clients retrying at the same moment. */
+const backoffMs = (attempt) => Math.min(500 * 2 ** attempt, 8e3) * (.75 + Math.random() * .25);
+/** How long to wait before the next try, or `undefined` to stop retrying. */
+const delayBeforeRetry = (attempt, headers) => {
+	const fromServer = retryAfterMs(headers);
+	if (fromServer === void 0) return backoffMs(attempt);
+	return fromServer <= 6e4 ? fromServer : void 0;
+};
+/** Wait `ms`. If `signal` fires first, stop waiting and reject with its reason. */
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+	if (signal?.aborted) return reject(signal.reason);
+	const onAbort = () => {
+		clearTimeout(timer);
+		reject(signal?.reason);
+	};
+	const timer = setTimeout(() => {
+		signal?.removeEventListener("abort", onAbort);
+		resolve();
+	}, ms);
+	signal?.addEventListener("abort", onAbort, { once: true });
+});
+/**
+* The production API address.
+* If it ever moves: change this line, bump the version and publish.
+* Until users update, they can set WITY_BASE_URL or the `baseURL` option.
+*/
+const DEFAULT_BASE_URL = "https://wity-proxy-production-2c33.up.railway.app";
+/** Extra time on top of `max_latency_ms` for the network and Wity's own work. */
+const LATENCY_MARGIN_MS = 1e4;
+/** The longest delay `setTimeout` accepts. A longer one fires at once. */
+const MAX_TIMER_MS = 2147483647;
+/** Wity's answers are a few kB. A body far bigger than that isn't a Wity answer, so the SDK stops reading. */
+const MAX_BODY_BYTES = 10485760;
+/**
+* Top-level fields each route accepts, from the API docs. `model` is accepted and ignored by Wity.
+* Other fields are still sent, so new API fields work without an SDK update, but the SDK logs a warning.
+*/
+const KNOWN_FIELDS = {
+	"/v1/systemone": /* @__PURE__ */ new Set([
+		"state",
+		"questions",
+		"reasoning",
+		"max_latency_ms",
+		"image",
+		"model"
+	]),
+	"/v1/generate": /* @__PURE__ */ new Set([
+		"state",
+		"instructions",
+		"shape",
+		"max_tokens",
+		"image",
+		"model"
+	])
+};
+const readEnv = (name) => {
+	if (typeof process === "undefined" || !process.env) return void 0;
+	return process.env[name]?.trim() || void 0;
+};
+/** A browser page, or a browser worker. Server runtimes have neither. */
+const inBrowser = () => {
+	const g = globalThis;
+	const page = typeof g.window !== "undefined" && typeof g.document !== "undefined";
+	const worker = typeof g.WorkerGlobalScope !== "undefined" && typeof g.importScripts === "function";
+	return page || worker;
+};
+/** Printable characters only, no spaces. */
+const KEY_PATTERN = /^[\x21-\x7E]+$/;
+const LOCAL_HOSTS = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"[::1]"
+]);
+/**
+* Check the base URL and return it without a trailing slash.
+* Error messages never repeat the URL, in case a key was pasted into it by mistake.
+*/
+const checkBaseURL = (raw) => {
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		throw new WityError("The Wity base URL is not a valid URL. Check WITY_BASE_URL or the baseURL option.");
+	}
+	const isLocalHttp = url.protocol === "http:" && LOCAL_HOSTS.has(url.hostname);
+	if (url.protocol !== "https:" && !isLocalHttp) throw new WityError("The Wity base URL must start with https:// so the API key is encrypted on the way. Plain http:// is only allowed for localhost.");
+	if (url.username || url.password) throw new WityError("The Wity base URL must not contain a username or password.");
+	if (url.search || url.hash) throw new WityError("The Wity base URL must not contain ? or #.");
+	return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+};
+/** Parse a body as JSON, or keep it as text. `undefined` when empty. */
+const readBody = async (response) => {
+	let text = "";
+	if (response.body) {
+		const reader = response.body.getReader();
+		const decoder = new TextDecoder();
+		let bytes = 0;
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			bytes += value.byteLength;
+			if (bytes > MAX_BODY_BYTES) {
+				await reader.cancel();
+				throw new WityError(`The answer is larger than ${MAX_BODY_BYTES / 1024 / 1024} MB, so it can't be from Wity. Check WITY_BASE_URL or the baseURL option.`);
+			}
+			text += decoder.decode(value, { stream: true });
+		}
+		text += decoder.decode();
+	}
+	if (text === "") return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+};
+/** Plain JavaScript can pass anything. Fail with a WityError before reading fields off it. */
+const checkRequest = (request) => {
+	if (typeof request !== "object" || request === null || Array.isArray(request)) throw new WityError("The request must be an object, for example { state, questions }.");
+};
+/** Client for the Wity API. Use it on a server only: it holds your API key. */
+var WityClient = class {
+	/** The address requests go to. Useful to check which API you're calling. */
+	baseURL;
+	timeoutMs;
+	maxRetries;
+	logLevel;
+	#apiKey;
+	#fetch;
+	#log;
+	constructor(options = {}) {
+		if (inBrowser()) throw new WityError("WityClient can't run in a browser. Your API key would be visible to anyone using the page. Call Wity from your server instead.");
+		const apiKey = options.apiKey !== void 0 ? options.apiKey.trim() : readEnv("WITY_API_KEY");
+		if (options.apiKey !== void 0 && !apiKey) throw new WityError("The apiKey option is empty. Pass a real key, or leave apiKey out to use WITY_API_KEY.");
+		if (!apiKey) throw new WityError("No API key found. Set the WITY_API_KEY environment variable, or pass apiKey to WityClient.");
+		if (!KEY_PATTERN.test(apiKey)) throw new WityError("The API key contains spaces or unusual characters. Check WITY_API_KEY.");
+		this.#apiKey = apiKey;
+		this.baseURL = checkBaseURL(options.baseURL ?? readEnv("WITY_BASE_URL") ?? "https://wity-proxy-production-2c33.up.railway.app");
+		this.timeoutMs = options.timeoutMs ?? 6e4;
+		if (!Number.isFinite(this.timeoutMs) || this.timeoutMs <= 0 || this.timeoutMs > MAX_TIMER_MS) throw new WityError(`timeoutMs must be a positive number of milliseconds, at most ${MAX_TIMER_MS}.`);
+		this.maxRetries = options.maxRetries ?? 2;
+		if (!Number.isInteger(this.maxRetries) || this.maxRetries < 0) throw new WityError("maxRetries must be a whole number, 0 or more.");
+		const levelFromEnv = readEnv("WITY_LOG_LEVEL");
+		this.logLevel = options.logLevel !== void 0 ? parseLogLevel(options.logLevel, "The logLevel option") : levelFromEnv !== void 0 ? parseLogLevel(levelFromEnv, "WITY_LOG_LEVEL") : DEFAULT_LOG_LEVEL;
+		this.#log = withLevel(options.logger ?? consoleLogger, this.logLevel);
+		this.#fetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+	}
+	/**
+	* Ask one or more typed questions about `state`.
+	* Answers come back under the same names as the questions.
+	*/
+	async systemOne(request, options = {}) {
+		checkRequest(request);
+		const latency = request.max_latency_ms;
+		const summary = {
+			questions: Object.keys(request.questions ?? {}),
+			reasoning: request.reasoning ?? "default"
+		};
+		return await this.#post("/v1/systemone", request, summary, {
+			signal: options.signal,
+			minTimeoutMs: Number.isFinite(latency) ? latency + LATENCY_MARGIN_MS : 0
+		});
+	}
+	/**
+	* Write short text from `state`, or JSON that matches `shape`.
+	* Pass the type of `value` yourself if you like: `generate<{ city: string }>(...)`.
+	*/
+	async generate(request, options = {}) {
+		checkRequest(request);
+		const summary = {
+			shape: request.shape !== void 0,
+			max_tokens: request.max_tokens ?? "default"
+		};
+		return await this.#post("/v1/generate", request, summary, {
+			signal: options.signal,
+			minTimeoutMs: 0
+		});
+	}
+	async #post(route, request, summary, { signal, minTimeoutMs }) {
+		const body = Object.fromEntries(Object.entries(request).filter(([, value]) => value !== void 0));
+		const unknown = Object.keys(body).filter((field) => !KNOWN_FIELDS[route].has(field)).map((field) => field.replace(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, "?"));
+		const unknownNote = unknown.length > 0 ? `The request included fields Wity may not know: ${unknown.join(", ")}.` : void 0;
+		if (unknownNote) this.#log.warn(`${route}: ${unknownNote} Check for typos.`);
+		const url = `${this.baseURL}${route}`;
+		let payload;
+		try {
+			payload = JSON.stringify(body);
+		} catch (err) {
+			throw new WityError("The request can't be turned into JSON. Look for BigInt values or loops in state.", { cause: err });
+		}
+		const timeoutMs = Math.min(Math.max(this.timeoutMs, minTimeoutMs), MAX_TIMER_MS);
+		const attempts = this.maxRetries + 1;
+		for (let attempt = 0;; attempt++) {
+			const canRetry = attempt < this.maxRetries;
+			const retryLabel = `retry ${attempt + 1} of ${this.maxRetries}`;
+			this.#log.debug(`${route}: sending (attempt ${attempt + 1} of ${attempts})`, {
+				url,
+				bytes: new TextEncoder().encode(payload).length,
+				...summary
+			});
+			const started = Date.now();
+			let response;
+			let data;
+			try {
+				({response, data} = await this.#send(url, payload, timeoutMs, signal));
+			} catch (err) {
+				const ms = Date.now() - started;
+				if (err instanceof APIConnectionError && canRetry) {
+					const delay = Math.round(backoffMs(attempt));
+					this.#log.info(`${route}: connection failed after ${ms} ms. Retrying in ${delay} ms (${retryLabel}).`, err.cause);
+					await this.#wait(delay, signal);
+					continue;
+				}
+				this.#log.info(`${route}: ${err.message} (after ${ms} ms)`);
+				throw err;
+			}
+			const requestId = requestIdFrom(response.headers);
+			this.#log.debug(`${route}: got ${response.status} in ${Date.now() - started} ms`, { requestId });
+			if (response.ok) {
+				if (typeof data !== "object" || data === null || Array.isArray(data)) throw new WityError("Wity answered with something that isn't a JSON object.");
+				return data;
+			}
+			if (canRetry && shouldRetryStatus(response.status)) {
+				const delay = delayBeforeRetry(attempt, response.headers);
+				if (delay !== void 0) {
+					this.#log.info(`${route}: got ${response.status}. Retrying in ${Math.round(delay)} ms (${retryLabel}).`, { requestId });
+					await this.#wait(delay, signal);
+					continue;
+				}
+				this.#log.warn(`${route}: got ${response.status}, and Retry-After asks for more than 60 s. Not retrying.`, { requestId });
+			}
+			throw APIError.fromResponse(response.status, data, response.headers, response.status === 400 ? unknownNote : void 0);
+		}
+	}
+	/**
+	* One attempt: send the request and read the whole answer.
+	* One timer and the caller's signal cover both steps, so a stalled or broken
+	* answer still ends in a WityError.
+	*/
+	async #send(url, payload, timeoutMs, signal) {
+		if (signal?.aborted) throw new APIUserAbortError("The request was cancelled.", { cause: signal.reason });
+		const controller = new AbortController();
+		let timedOut = false;
+		const timer = setTimeout(() => {
+			timedOut = true;
+			controller.abort();
+		}, timeoutMs);
+		const onCallerAbort = () => controller.abort();
+		signal?.addEventListener("abort", onCallerAbort, { once: true });
+		try {
+			const response = await this.#fetch(url, {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${this.#apiKey}`,
+					"Content-Type": "application/json",
+					Accept: "application/json"
+				},
+				body: payload,
+				redirect: "manual",
+				signal: controller.signal
+			});
+			return {
+				response,
+				data: await readBody(response)
+			};
+		} catch (err) {
+			if (err instanceof WityError) throw err;
+			if (timedOut) throw new APITimeoutError(`Wity didn't answer within ${timeoutMs} ms.`, { cause: err });
+			if (signal?.aborted) throw new APIUserAbortError("The request was cancelled.", { cause: err });
+			throw new APIConnectionError(`Couldn't reach the Wity API at ${this.baseURL}, or the connection broke while reading its answer.`, { cause: err });
+		} finally {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", onCallerAbort);
+		}
+	}
+	/** Wait between retries. Cancelling through `signal` stops the wait. */
+	async #wait(ms, signal) {
+		try {
+			await sleep(ms, signal);
+		} catch (reason) {
+			this.#log.info("Cancelled while waiting to retry.");
+			throw new APIUserAbortError("The request was cancelled.", { cause: reason });
+		}
+	}
+};
+/**
+* Pick one option.
+*
+* @example choice("Which team?", { billing: "Payments and refunds", technical: "Bugs" })
+*/
+const choice = (instructions, criteria) => ({
+	type: "choice",
+	instructions,
+	criteria
+});
+/**
+* Yes or no. Optionally describe what yes and no mean.
+*
+* @example noul("Is this urgent?", { true: "Needs action today", false: "Can wait" })
+*/
+const noul = (instructions, criteria) => criteria === void 0 ? {
+	type: "noul",
+	instructions
+} : {
+	type: "noul",
+	instructions,
+	criteria
+};
+/**
+* Pick a level on a scale of 2 to 10 levels, lowest first.
+* Levels can come from a variable, for example a list loaded from a database.
+*
+* @example score("How upset is the customer?", ["Calm", "Annoyed", "Angry"])
+*/
+const score = (instructions, criteria) => ({
+	type: "score",
+	instructions,
+	criteria
+});
+//#endregion
+//#region src/exit.ts
+const EXIT = {
+	ok: 0,
+	/** The API, the network or something else failed. */
+	error: 1,
+	/** Bad flags or bad input. Nothing was sent, or Wity refused the request (400). Nothing was billed. */
+	usage: 2,
+	/** No key, or the key was refused. */
+	auth: 3,
+	/** The answer came back, but it failed `--fail-under` or `--expect`. */
+	gate: 10,
+	/** Ctrl+C. */
+	cancelled: 130
+};
+/** An error meant for the person at the terminal. `message` is printed as is, so write it for them. */
+var CliError = class extends Error {
+	name = "CliError";
+	code;
+	/** One extra line on what to do next. */
+	hint;
+	constructor(message, code = EXIT.error, hint) {
+		super(message);
+		this.code = code;
+		this.hint = hint;
+	}
+};
+//#endregion
+//#region src/config.ts
+/** The website, where people sign in and manage keys. */
+const CONSOLE_URL = "https://wity.alphanimble.com";
+const KEYS_PAGE = `${CONSOLE_URL}/console/keys`;
+const BILLING_PAGE = `${CONSOLE_URL}/console/billing`;
+/** Dollars per million input tokens, from wity.alphanimble.com/pricing. Output and thinking are free. */
+const PRICE_PER_MILLION_INPUT_USD = .042;
+/**
+* The API address: `--base-url`, then WITY_BASE_URL, then the SDK's default.
+* Returned in the same form the SDK uses (no trailing slash), because saved keys are filed under it.
+* The SDK does the full check (https only, no user or password) when the client is made.
+*/
+const resolveBaseURL = (flag, env) => {
+	const raw = flag?.trim() || env.WITY_BASE_URL?.trim() || "https://wity-proxy-production-2c33.up.railway.app";
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		throw new CliError("The API address is not a valid URL. Check --base-url or WITY_BASE_URL.", EXIT.usage);
+	}
+	return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+};
+//#endregion
+//#region src/output.ts
+/** NO_COLOR and TERM=dumb turn colour off. FORCE_COLOR turns it on. Otherwise only on a terminal. */
+const shouldColor = (env, stream) => {
+	if (env.NO_COLOR) return false;
+	if (env.FORCE_COLOR && env.FORCE_COLOR !== "0") return true;
+	if (env.TERM === "dumb") return false;
+	return Boolean(stream.isTTY);
+};
+const painter = (on) => (style, text) => on ? styleText(style, text, { validateStream: false }) : text;
+/** Spinners and other redrawing. Off in CI and when output isn't a terminal. */
+const canAnimate = (io, stream) => Boolean(stream.isTTY) && !io.env.CI;
+/** An OSC sequence (window title, hyperlink): ESC ] ... ended by BEL or ESC \. Node's strip leaves its text behind. */
+const OSC = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?/g;
+/**
+* Text from the API or from a file, made safe for one line of a terminal.
+* Escape codes and control characters are removed, so text can't move the cursor, change colours or fake output.
+*/
+const clean = (text) => stripVTControlCharacters(text.replace(OSC, "")).replace(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]+/gu, " ").trim();
+/** Like `clean`, for text of many lines: line breaks and tabs stay, everything else that could act on a terminal goes. */
+const cleanBlock = (text) => stripVTControlCharacters(text.replace(OSC, "")).replace(/\r\n?|[\u2028\u2029]/g, "\n").replace(/[\p{Cc}\p{Cf}]/gu, (ch) => ch === "\n" || ch === "	" ? ch : "");
+/** Shorten to `max` characters, with an ellipsis. */
+const truncate = (text, max) => text.length > max ? `${text.slice(0, max - 1)}…` : text;
+/**
+* A probability as a percentage with 2 decimals.
+* Values that would print as 0.00% or 100.00% print as <0.01% or >99.99%, so nothing looks certain when it isn't.
+*/
+const pct = (p) => {
+	if (p <= 0) return "0%";
+	if (p >= 1) return "100%";
+	if (p < 5e-5) return "<0.01%";
+	if (p >= .99995) return ">99.99%";
+	return `${(p * 100).toFixed(2)}%`;
+};
+const PARTS = [
+	"",
+	"▏",
+	"▎",
+	"▍",
+	"▌",
+	"▋",
+	"▊",
+	"▉"
+];
+/** A bar `width` cells wide, filled in eighths of a cell. */
+const bar = (p, width, paint, style) => {
+	const eighths = Math.round(Math.min(1, Math.max(0, p)) * width * 8);
+	const full = Math.floor(eighths / 8);
+	const part = PARTS[eighths % 8] ?? "";
+	const filled = "█".repeat(full) + part;
+	const empty = width - full - (part ? 1 : 0);
+	return (filled ? paint(style, filled) : "") + (empty > 0 ? paint("dim", "·".repeat(empty)) : "");
+};
+/** A 0–1 value like confidence, with 3 decimals. Like `pct`, it never rounds to exactly 0 or 1. */
+const decimal = (value) => {
+	if (value > 0 && value < 5e-4) return "<0.001";
+	if (value < 1 && value >= .9995) return ">0.999";
+	return value.toFixed(3);
+};
+/** Estimated cost of `tokens` input tokens, like "$0.000012". The bill itself is worked out by Wity. */
+const cost = (tokens) => {
+	const usd = tokens * PRICE_PER_MILLION_INPUT_USD / 1e6;
+	if (usd === 0) return "$0";
+	const decimals = usd >= .01 ? 2 : -Math.floor(Math.log10(usd)) + 1;
+	return `$${usd.toFixed(decimals)}`;
+};
+const ms = (value) => value >= 1e4 ? `${(value / 1e3).toFixed(1)} s` : `${Math.round(value)} ms`;
+const writeJson = (io, value) => {
+	io.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+};
+const FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏";
+/**
+* A spinner on stderr while a call runs. After `slowAfterMs` the text changes to `slowText`, if given.
+* `text` can be a function, for a label that changes, like a countdown.
+* Returns a function that clears it. Does nothing when stderr isn't a terminal or in CI.
+*/
+const spinner = (io, text, slowText, slowAfterMs = 1500) => {
+	if (!canAnimate(io, io.stderr)) return () => {};
+	const paint = painter(shouldColor(io.env, io.stderr));
+	const started = Date.now();
+	let frame = 0;
+	const draw = () => {
+		const label = slowText && Date.now() - started > slowAfterMs ? slowText : typeof text === "string" ? text : text();
+		io.stderr.write(`\r\x1b[2K  ${paint("cyan", FRAMES[frame++ % 10] ?? "")} ${paint("dim", label)}`);
+	};
+	io.stderr.write("\x1B[?25l");
+	draw();
+	const timer = setInterval(draw, 80);
+	return () => {
+		clearInterval(timer);
+		io.stderr.write("\r\x1B[2K\x1B[?25h");
+	};
+};
+//#endregion
+//#region src/api.ts
+/** How long the CLI's own checks (health, key) wait. API calls use the SDK's timeouts. */
+const CHECK_TIMEOUT_MS = 15e3;
+/**
+* A client for `baseURL`. The SDK checks the address here: https only, plain http only for localhost.
+* Its log lines go to stderr, so stdout stays clean for JSON.
+*/
+const makeClient = (key, baseURL, io) => {
+	try {
+		return new WityClient({
+			apiKey: key,
+			baseURL,
+			logLevel: io.env.WITY_LOG_LEVEL?.trim() ? io.env.WITY_LOG_LEVEL.trim() : void 0,
+			logger: {
+				debug: (message, ...args) => io.stderr.write(`${format(`[wity] ${message}`, ...args)}\n`),
+				info: (message, ...args) => io.stderr.write(`${format(`[wity] ${message}`, ...args)}\n`),
+				warn: (message, ...args) => io.stderr.write(`${format(`[wity] ${message}`, ...args)}\n`),
+				error: (message, ...args) => io.stderr.write(`${format(`[wity] ${message}`, ...args)}\n`)
+			}
+		});
+	} catch (err) {
+		if (err instanceof WityError) throw new CliError(err.message, EXIT.usage);
+		throw err;
+	}
+};
+/**
+* A GET that never follows redirects, so a key only goes to the address it was meant for.
+* Throws a CliError if the address can't be reached.
+*/
+const get = async (url, io, key) => {
+	const started = performance.now();
+	try {
+		const response = await fetch(url, {
+			headers: key ? { Authorization: `Bearer ${key}` } : {},
+			redirect: "manual",
+			signal: AbortSignal.any([io.signal, AbortSignal.timeout(CHECK_TIMEOUT_MS)])
+		});
+		await response.body?.cancel();
+		return {
+			status: response.status,
+			ms: performance.now() - started
+		};
+	} catch (err) {
+		if (io.signal.aborted) throw new CliError("Cancelled.", EXIT.cancelled);
+		throw new CliError(err instanceof Error && err.name === "TimeoutError" ? `No answer from Wity within ${CHECK_TIMEOUT_MS / 1e3} s.` : "Couldn't reach Wity.", EXIT.error, "Check your internet connection. `wity doctor` runs a full check.");
+	}
+};
+/** GET /health. Needs no key. */
+const checkHealth = (baseURL, io) => get(`${baseURL}/health`, io);
+/**
+* GET /v1/models with the key. 200 means the key works, 401 means it was refused.
+* This call isn't billed, so it's safe to run on every `api-key set` and `api-key show`.
+*/
+const checkKey = (key, baseURL, io) => {
+	const client = makeClient(key, baseURL, io);
+	return get(`${client.baseURL}/v1/models`, io, key);
+};
+/** What to do when a key is refused, depending on where it came from. */
+const refusedHint = (found) => found.source === "env" ? "The key comes from WITY_API_KEY. Check it, or unset it to use the key saved by `wity api-key set`." : "It may have been revoked. Run `wity api-key set` to save a new key.";
+/** Turn an SDK error into a message and exit code for the terminal. */
+const explain = (err, found) => {
+	if (!(err instanceof WityError)) return err;
+	const id = err instanceof APIError && err.requestId ? ` Request id: ${clean(err.requestId)}` : "";
+	if (err instanceof AuthenticationError) return new CliError("Wity refused the API key.", EXIT.auth, refusedHint(found));
+	if (err instanceof InsufficientBalanceError) return new CliError("Your Wity balance has run out.", EXIT.error, `Add credits at ${BILLING_PAGE}`);
+	if (err instanceof BadRequestError) return new CliError(`Wity refused the request: ${clean(err.message)}`, EXIT.usage, `Nothing was billed.${id}`);
+	if (err instanceof RateLimitError) return new CliError("Too many requests at once for this key.", EXIT.error, `Wait a moment and try again.${id}`);
+	if (err instanceof APIUserAbortError) return new CliError("Cancelled.", EXIT.cancelled);
+	if (err instanceof APITimeoutError) return new CliError("Wity didn't answer in time.", EXIT.error, "Try again, or set --max-latency to cap thinking time.");
+	if (err instanceof APIConnectionError) return new CliError("Couldn't reach Wity.", EXIT.error, "Check your internet connection. `wity doctor` runs a full check.");
+	if (err instanceof APIError) return new CliError(`Wity answered with an error: ${clean(err.message)}`, EXIT.error, id.trim() || void 0);
+	return new CliError(clean(err.message), EXIT.usage);
+};
+//#endregion
+//#region src/credentials.ts
+const SERVICE = "wity-cli";
+/** Checks a stored record, so a hand-edited or broken one is reported instead of used. */
+const parseSaved = (value, baseURL) => {
+	if (typeof value !== "object" || value === null) return void 0;
+	const { key, savedAt, via } = value;
+	if (typeof key !== "string" || key === "") return void 0;
+	return {
+		key,
+		baseURL,
+		savedAt: typeof savedAt === "string" ? savedAt : "",
+		via: via === "argument" || via === "token" ? via : "paste"
+	};
+};
+/** What goes into the keychain or the file. The address is the entry's name, so it isn't repeated inside. */
+const record = ({ key, savedAt, via }) => ({
+	key,
+	savedAt,
+	via
+});
+const KEYCHAIN_NAMES = {
+	darwin: "macOS Keychain",
+	win32: "Windows Credential Manager",
+	linux: "the Secret Service keyring"
+};
+/** The keychain store, or `undefined` if this machine doesn't have a working one. */
+const keychainStore = async () => {
+	let AsyncEntry;
+	try {
+		({AsyncEntry} = await import("@napi-rs/keyring"));
+	} catch {
+		return;
+	}
+	const options = { linux: { store: "secret-service" } };
+	const entry = (baseURL) => new AsyncEntry(SERVICE, baseURL, options);
+	try {
+		await entry("probe").getPassword();
+	} catch {
+		return;
+	}
+	return {
+		kind: "keychain",
+		location: KEYCHAIN_NAMES[process.platform] ?? "the system keychain",
+		async get(baseURL) {
+			const raw = await entry(baseURL).getPassword();
+			if (raw === void 0) return void 0;
+			try {
+				return parseSaved(JSON.parse(raw), baseURL);
+			} catch {
+				return;
+			}
+		},
+		async set(saved) {
+			await entry(saved.baseURL).setPassword(JSON.stringify(record(saved)));
+		},
+		async delete(baseURL) {
+			return entry(baseURL).deletePassword();
+		}
+	};
+};
+/** `~/.config/wity/credentials.json`, or under XDG_CONFIG_HOME or APPDATA when set. */
+const credentialsPath = (env) => {
+	const base = env.XDG_CONFIG_HOME?.trim() || process.platform === "win32" && env.APPDATA?.trim() || join(env.HOME?.trim() || homedir(), ".config");
+	return join(base, "wity", "credentials.json");
+};
+/** POSIX permission checks. Windows files don't carry these modes, so it relies on the profile folder's ACLs. */
+const checkPrivate = async (path, what) => {
+	let info;
+	try {
+		info = await lstat(path);
+	} catch (err) {
+		if (err.code === "ENOENT") return false;
+		throw err;
+	}
+	if (process.platform === "win32") return true;
+	if (info.isSymbolicLink()) throw new CliError(`The credentials ${what} is a symbolic link, so it isn't used: ${path}`, EXIT.auth);
+	if (typeof process.getuid === "function" && info.uid !== process.getuid()) throw new CliError(`The credentials ${what} belongs to another user, so it isn't used: ${path}`, EXIT.auth);
+	if (what === "file" ? info.mode & 63 : info.mode & 18) {
+		const fix = what === "file" ? `chmod 600 "${path}"` : `chmod 700 "${path}"`;
+		throw new CliError(`Other users can access the credentials ${what}, so it isn't used: ${path}`, EXIT.auth, `Fix it with: ${fix}`);
+	}
+	return true;
+};
+const fileStore = (env) => {
+	const path = credentialsPath(env);
+	const folder = dirname(path);
+	const readAll = async () => {
+		if (!await checkPrivate(path, "file")) return {};
+		try {
+			const data = JSON.parse(await readFile(path, "utf8"));
+			if (typeof data === "object" && data !== null && !Array.isArray(data)) return data;
+		} catch {}
+		throw new CliError(`The credentials file is damaged: ${path}`, EXIT.auth, "Delete it and run `wity api-key set` again.");
+	};
+	const writeAll = async (data) => {
+		await mkdir(folder, {
+			recursive: true,
+			mode: 448
+		});
+		await checkPrivate(folder, "folder");
+		const temp = `${path}.${process.pid}.tmp`;
+		await writeFile(temp, `${JSON.stringify(data, null, 2)}\n`, {
+			mode: 384,
+			flag: "wx"
+		});
+		try {
+			await rename(temp, path);
+		} catch (err) {
+			await rm(temp, { force: true });
+			throw err;
+		}
+	};
+	return {
+		kind: "file",
+		location: path,
+		async get(baseURL) {
+			return parseSaved((await readAll())[baseURL], baseURL);
+		},
+		async set(saved) {
+			const all = await readAll();
+			all[saved.baseURL] = record(saved);
+			await writeAll(all);
+		},
+		async delete(baseURL) {
+			const all = await readAll();
+			if (!(baseURL in all)) return false;
+			delete all[baseURL];
+			if (Object.keys(all).length === 0) await rm(path, { force: true });
+			else await writeAll(all);
+			return true;
+		}
+	};
+};
+const openStore = async (env) => {
+	const wanted = (env.WITY_CREDENTIAL_STORE ?? "auto").trim().toLowerCase() || "auto";
+	if (![
+		"auto",
+		"keychain",
+		"file"
+	].includes(wanted)) throw new CliError("WITY_CREDENTIAL_STORE must be auto, keychain or file.", EXIT.usage);
+	if (wanted === "file") return fileStore(env);
+	const keychain = await keychainStore();
+	if (keychain) return keychain;
+	if (wanted === "keychain") throw new CliError("No working keychain was found on this machine.", EXIT.auth, "Unset WITY_CREDENTIAL_STORE to save the key in a private file instead.");
+	return fileStore(env);
+};
+/** WITY_API_KEY wins over a saved key, like in the SDK. `wity api-key show` says which one is in use. */
+const findKey = async (baseURL, env, store) => {
+	const fromEnv = env.WITY_API_KEY?.trim();
+	if (fromEnv) return {
+		key: fromEnv,
+		source: "env",
+		location: "the WITY_API_KEY environment variable"
+	};
+	const opened = await store();
+	const saved = await opened.get(baseURL);
+	return saved && {
+		key: saved.key,
+		source: opened.kind,
+		location: opened.location,
+		saved
+	};
+};
+/**
+* What's safe to show of a key: its first 9 characters, like the console's key list ("wity_Ab12…").
+* Console keys are 48 characters. A short, unusual key shows only 4, so most of it stays hidden.
+*/
+const keyPrefix = (key) => `${key.slice(0, key.length >= 24 ? 9 : 4)}…`;
+//#endregion
+//#region src/input.ts
+/** Wity reads at most this many characters of state. From wity.alphanimble.com/docs/limits. */
+const MAX_STATE_CHARS = 32e3;
+/** Stop reading input past this size. Far above what Wity accepts, and small enough to keep in memory. */
+const MAX_READ_BYTES = 4194304;
+const tooBig = () => new CliError(`The input is over ${MAX_READ_BYTES / 1024 / 1024} MB. Wity reads at most ${MAX_STATE_CHARS} characters.`, EXIT.usage);
+/** Everything on stdin, as text. */
+const readStdin = async (stdin) => {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of stdin) {
+		const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+		size += buffer.length;
+		if (size > MAX_READ_BYTES) throw tooBig();
+		chunks.push(buffer);
+	}
+	return Buffer.concat(chunks).toString("utf8");
+};
+/** The text to judge: `--text`, `--file` (`-` is stdin), or piped in. Exactly one of them. */
+const readState = async (flags, io) => {
+	if (flags.text !== void 0 && flags.file !== void 0) throw new CliError("Give the text with --text or --file, not both.", EXIT.usage);
+	let text;
+	if (flags.text !== void 0) text = flags.text;
+	else if (flags.file !== void 0 && flags.file !== "-") {
+		let info;
+		try {
+			info = await stat(flags.file);
+		} catch {
+			throw new CliError(`Can't read the file ${flags.file}`, EXIT.usage);
+		}
+		if (!info.isFile()) throw new CliError(`${flags.file} is not a file.`, EXIT.usage);
+		if (info.size > MAX_READ_BYTES) throw tooBig();
+		text = await readFile(flags.file, "utf8");
+	} else if (flags.file === "-" || !io.stdin.isTTY) text = await readStdin(io.stdin);
+	else throw new CliError("No text to judge.", EXIT.usage, "Pass it with --text \"...\", --file path, or pipe it in: cat email.txt | wity noul \"Is this spam?\"");
+	text = text.replace(/^/, "");
+	if (text.trim() === "") throw new CliError("The text to judge is empty.", EXIT.usage);
+	const length = Array.from(text).length;
+	if (length > 32e3) throw new CliError(`The text is ${length.toLocaleString("en")} characters. Wity reads at most ${MAX_STATE_CHARS.toLocaleString("en")}.`, EXIT.usage);
+	return text;
+};
+/**
+* Ask for a secret on the terminal without showing it. Nothing is echoed, not even dots.
+* Ctrl+C cancels. Escape sequences (arrow keys, bracketed paste markers) are skipped.
+*/
+const readHidden = (io, prompt) => {
+	const { stdin } = io;
+	if (!stdin.isTTY || !stdin.setRawMode) return Promise.reject(new CliError("There's no terminal to type the key into.", EXIT.usage, "Pipe it in instead: wity api-key set --stdin < key.txt"));
+	io.stderr.write(prompt);
+	const setRawMode = stdin.setRawMode.bind(stdin);
+	setRawMode(true);
+	stdin.setEncoding("utf8");
+	stdin.resume();
+	return new Promise((resolve, reject) => {
+		let value = "";
+		let inEscape = false;
+		const finish = (err) => {
+			stdin.off("data", onData);
+			setRawMode(false);
+			stdin.pause();
+			io.stderr.write("\n");
+			if (err) reject(err);
+			else resolve(value);
+		};
+		const onData = (chunk) => {
+			for (const ch of String(chunk)) {
+				if (inEscape) {
+					if (/[A-Za-z~]/.test(ch)) inEscape = false;
+					continue;
+				}
+				if (ch === "\x1B") inEscape = true;
+				else if (ch === "\r" || ch === "\n" || ch === "") return finish();
+				else if (ch === "") return finish(new CliError("Cancelled.", EXIT.cancelled));
+				else if (ch === "" || ch === "\b") value = Array.from(value).slice(0, -1).join("");
+				else if (ch >= " ") value += ch;
+			}
+		};
+		stdin.on("data", onData);
+	});
+};
+//#endregion
+//#region src/schema.ts
+const text = z.string().trim().min(1, "can't be empty");
+const noulSchema = z.strictObject({
+	type: z.literal("noul"),
+	instructions: text,
+	criteria: z.strictObject({
+		true: text,
+		false: text
+	}).optional()
+});
+const choiceSchema = z.strictObject({
+	type: z.literal("choice"),
+	instructions: text,
+	criteria: z.record(z.string().trim().min(1, "option ids can't be empty"), z.string()).refine((options) => Object.keys(options).length >= 2 && Object.keys(options).length <= 256, "needs 2 to 256 options")
+});
+const scoreSchema = z.strictObject({
+	type: z.literal("score"),
+	instructions: text,
+	criteria: z.array(text).min(2, "needs 2 to 10 levels").max(10, "needs 2 to 10 levels")
+});
+const questionSchema = z.discriminatedUnion("type", [
+	noulSchema,
+	choiceSchema,
+	scoreSchema
+]);
+const questionsSchema = z.record(z.string().trim().min(1, "question names can't be empty").max(64), questionSchema).refine((questions) => Object.keys(questions).length > 0, "needs at least one question");
+/** Text, or an object or array that Wity reads as JSON. */
+const stateSchema = z.union([
+	text,
+	z.record(z.string(), z.json()),
+	z.array(z.json())
+]);
+const reasoningSchema = z.enum([
+	"off",
+	"auto",
+	"always"
+]);
+/** A `wity ask -f` file. `state` is optional there: it can come from --text, --file or a pipe instead. */
+const askFileSchema = z.strictObject({
+	state: stateSchema.optional(),
+	questions: questionsSchema,
+	reasoning: reasoningSchema.optional(),
+	max_latency_ms: z.number().int().min(200).max(12e4).optional()
+});
+/** State length as Wity counts it: characters of the text, or of the JSON for an object. */
+const stateLength = (state) => typeof state === "string" ? Array.from(state).length : JSON.stringify(state).length;
+const checkStateLength = (state) => {
+	const length = stateLength(state);
+	if (length > 32e3) throw new CliError(`The state is ${length.toLocaleString("en")} characters. Wity reads at most ${MAX_STATE_CHARS.toLocaleString("en")}.`, EXIT.usage);
+};
+/** Zod's issues as one line each: "questions.team.criteria: needs 2 to 256 options". */
+const describeIssues = (error) => error.issues.map((issue) => `${issue.path.join(".") || "(file)"}: ${issue.message}`).join("\n    ");
+//#endregion
+//#region src/send.ts
+const requireKey = async (ctx) => {
+	const found = await findKey(ctx.baseURL, ctx.io.env, ctx.store);
+	if (!found) throw new CliError("No API key found.", EXIT.auth, "Run `wity api-key set`, or set WITY_API_KEY.");
+	return found;
+};
+const sendSystemOne = async (ctx, request) => {
+	const found = await requireKey(ctx);
+	const client = makeClient(found.key, ctx.baseURL, ctx.io);
+	const stop = spinner(ctx.io, "Asking Wity…", "Still working. Wity may be thinking this one through…");
+	const started = performance.now();
+	try {
+		return {
+			res: await client.systemOne(request, { signal: ctx.io.signal }),
+			totalMs: performance.now() - started
+		};
+	} catch (err) {
+		throw explain(err, found);
+	} finally {
+		stop();
+	}
+};
+const sendGenerate = async (ctx, request) => {
+	const found = await requireKey(ctx);
+	const client = makeClient(found.key, ctx.baseURL, ctx.io);
+	const stop = spinner(ctx.io, "Writing…", "Still writing…");
+	const started = performance.now();
+	try {
+		return {
+			res: await client.generate(request, { signal: ctx.io.signal }),
+			totalMs: performance.now() - started
+		};
+	} catch (err) {
+		throw explain(err, found);
+	} finally {
+		stop();
+	}
+};
+//#endregion
+export { truncate as A, score as B, cost as C, pct as D, painter as E, CliError as F, EXIT as I, DEFAULT_BASE_URL as L, KEYS_PAGE as M, PRICE_PER_MILLION_INPUT_USD as N, shouldColor as O, resolveBaseURL as P, choice as R, cleanBlock as S, ms as T, explain as _, checkStateLength as a, bar as b, MAX_STATE_CHARS as c, readStdin as d, findKey as f, checkKey as g, checkHealth as h, askFileSchema as i, writeJson as j, spinner as k, readHidden as l, openStore as m, sendGenerate as n, describeIssues as o, keyPrefix as p, sendSystemOne as r, questionSchema as s, requireKey as t, readState as u, makeClient as v, decimal as w, clean as x, refusedHint as y, noul as z };