wity-cli 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,509 @@
+#!/usr/bin/env node
+import { t as version } from "./package-7FOUqcPO.mjs";
+import { C as cost, E as painter, F as CliError, I as EXIT, M as KEYS_PAGE, O as shouldColor, P as resolveBaseURL, S as cleanBlock, T as ms, a as checkStateLength, d as readStdin, f as findKey, g as checkKey, h as checkHealth, i as askFileSchema, j as writeJson, k as spinner, l as readHidden, m as openStore, n as sendGenerate, o as describeIssues, p as keyPrefix, r as sendSystemOne, u as readState, x as clean, y as refusedHint } from "./send-CGXuVi9Z.mjs";
+import { a as scoreQuestion, c as codeLangs, d as printCode, f as systemOneTs, i as pickField, l as curl, n as choiceQuestion, o as renderAnswer, r as noulQuestion, s as renderFooter, t as ask, u as generateTs } from "./questions-eZ01WB1q.mjs";
+import { Command, CommanderError, InvalidArgumentError, Option } from "commander";
+import { readFile, stat } from "node:fs/promises";
+import { parse } from "yaml";
+//#region src/io.ts
+const processIo = (signal) => ({
+	env: process.env,
+	stdin: process.stdin,
+	stdout: process.stdout,
+	stderr: process.stderr,
+	signal
+});
+//#endregion
+//#region src/commands/api-key.ts
+/** Printable characters only, no spaces. The SDK refuses anything else. */
+const KEY_PATTERN = /^[\x21-\x7E]+$/;
+const envWarning = (ctx, text) => {
+	if (ctx.io.env.WITY_API_KEY?.trim()) ctx.io.stderr.write(`  ${ctx.err("yellow", "▲")} ${text}\n\n`);
+};
+/** Shown only when it isn't the usual address, so people notice they're pointed somewhere else. */
+const addressLine = (ctx) => ctx.baseURL === "https://wity-proxy-production-2c33.up.railway.app" ? "" : `    ${ctx.err("dim", "API".padEnd(9))} ${ctx.baseURL}\n`;
+const when = (iso) => new Date(iso).toLocaleString("en-GB", {
+	dateStyle: "medium",
+	timeStyle: "short"
+});
+/**
+* Check the key with the free /v1/models call, then save it. A key saved before is replaced.
+* The key comes from the command line, stdin (--stdin), or a hidden prompt, in that order.
+*/
+const setKey = async (ctx, opts, given) => {
+	const { io } = ctx;
+	if (given !== void 0 && opts.stdin) throw new CliError("Give the key on the command line or with --stdin, not both.", EXIT.usage);
+	const via = given !== void 0 ? "argument" : opts.stdin ? "token" : "paste";
+	let key;
+	if (via === "argument") key = (given ?? "").trim();
+	else if (via === "token") {
+		if (io.stdin.isTTY) throw new CliError("--stdin reads the key from stdin.", EXIT.usage, "Pipe it in: wity api-key set --stdin < key.txt");
+		key = (await readStdin(io.stdin)).trim();
+	} else {
+		io.stderr.write(`\n  ${ctx.err("bold", "Save your Wity API key")}\n\n`);
+		io.stderr.write(`  Create a key at ${ctx.err("cyan", KEYS_PAGE)} and paste it below.\n`);
+		io.stderr.write(`  ${ctx.err("dim", "Nothing shows while you paste. Press Enter when done.")}\n\n`);
+		key = (await readHidden(io, "  API key: ")).trim();
+	}
+	if (!key) throw new CliError("No key was given.", EXIT.usage);
+	if (!KEY_PATTERN.test(key)) throw new CliError("The key has spaces or unusual characters.", EXIT.usage, "Check that you copied the whole key and nothing else.");
+	const stop = spinner(io, "Checking the key…", "Still checking the key…");
+	let check;
+	try {
+		check = await checkKey(key, ctx.baseURL, io);
+	} finally {
+		stop();
+	}
+	if (check.status === 401) throw new CliError("Wity refused this key.", EXIT.auth, "Check that you copied all of it, and that it hasn't been revoked.");
+	if (check.status !== 200) throw new CliError(`Couldn't check the key. Wity answered ${check.status}.`, EXIT.error);
+	const store = await ctx.store();
+	await store.set({
+		key,
+		baseURL: ctx.baseURL,
+		savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		via
+	});
+	io.stderr.write(`\n  ${ctx.err("green", "✓")} ${ctx.err("bold", "Saved.")} The key works.\n\n`);
+	io.stderr.write(`    ${ctx.err("dim", "Key".padEnd(9))} ${keyPrefix(key)}\n`);
+	io.stderr.write(`    ${ctx.err("dim", "Saved in")}  ${store.location}\n`);
+	io.stderr.write(addressLine(ctx));
+	io.stderr.write("\n");
+	envWarning(ctx, "WITY_API_KEY is set in this shell, and it wins over the saved key. Unset it to use the saved one.");
+	return EXIT.ok;
+};
+/** Remove the saved key from this computer. The key itself keeps working until it's revoked on the website. */
+const removeKey = async (ctx) => {
+	const { io } = ctx;
+	const p = ctx.err;
+	const store = await ctx.store();
+	if (!await store.delete(ctx.baseURL)) {
+		io.stderr.write(`\n  There's no saved key on this computer${ctx.baseURL === "https://wity-proxy-production-2c33.up.railway.app" ? "" : ` for ${ctx.baseURL}`}.\n\n`);
+		envWarning(ctx, "WITY_API_KEY is set in this shell, so commands keep using it. Remove it with: unset WITY_API_KEY");
+		return EXIT.ok;
+	}
+	io.stderr.write(`\n  ${p("green", "✓")} ${p("bold", "Removed the key")} from ${store.location}.\n`);
+	io.stderr.write(`    ${p("dim", `It still works until you revoke it at ${KEYS_PAGE}`)}\n\n`);
+	envWarning(ctx, "WITY_API_KEY is still set in this shell, so commands keep using it. Remove it with: unset WITY_API_KEY");
+	return EXIT.ok;
+};
+const showKey = async (ctx, opts) => {
+	const { io } = ctx;
+	const found = await findKey(ctx.baseURL, 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.");
+	const stop = opts.json ? () => {} : spinner(io, "Checking the key…", "Still checking the key…");
+	let check;
+	let problem;
+	try {
+		check = await checkKey(found.key, ctx.baseURL, io);
+	} catch (err) {
+		if (!(err instanceof CliError) || err.code === EXIT.cancelled) throw err;
+		problem = err.message;
+	} finally {
+		stop();
+	}
+	const works = check ? check.status === 200 : void 0;
+	if (opts.json || !io.stdout.isTTY) writeJson(io, {
+		api: ctx.baseURL,
+		key: keyPrefix(found.key),
+		source: found.source,
+		location: found.location,
+		saved_at: found.saved?.savedAt || null,
+		works: works ?? null
+	});
+	else {
+		const p = ctx.out;
+		const line = (label, value) => io.stdout.write(`    ${p("dim", label.padEnd(9))} ${value}\n`);
+		const dot = works === true ? p("green", "●") : works === false ? p("red", "●") : p("yellow", "●");
+		const title = works === false ? "The key was refused" : "Wity API key";
+		io.stdout.write(`\n  ${dot} ${p("bold", title)}\n\n`);
+		line("Key", keyPrefix(found.key));
+		line("From", `${found.location}${found.saved?.savedAt ? ` · saved ${when(found.saved.savedAt)}` : ""}`);
+		line("API", ctx.baseURL);
+		line("Status", works === true ? `${p("green", "works")} ${p("dim", `· checked in ${ms(check?.ms ?? 0)}`)}` : works === false ? p("red", "refused") : p("yellow", `not checked: ${problem ?? "no answer"}`));
+		io.stdout.write("\n");
+		if (works === false) io.stdout.write(`  ${p("dim", refusedHint(found))}\n\n`);
+	}
+	if (works === false) return EXIT.auth;
+	if (works === void 0) return EXIT.error;
+	return EXIT.ok;
+};
+//#endregion
+//#region src/commands/ask.ts
+/** Question files are small. Anything bigger is a mistake. */
+const MAX_FILE_BYTES = 1048576;
+/** Read a YAML or JSON file (JSON is valid YAML). */
+const readDataFile = async (path, what) => {
+	let size;
+	try {
+		size = (await stat(path)).size;
+	} catch {
+		throw new CliError(`Can't read the ${what} ${path}`, EXIT.usage);
+	}
+	if (size > MAX_FILE_BYTES) throw new CliError(`The ${what} is over 1 MB.`, EXIT.usage);
+	try {
+		return parse(await readFile(path, "utf8"));
+	} catch (err) {
+		throw new CliError(`The ${what} isn't valid YAML or JSON: ${clean(err.message).slice(0, 200)}`, EXIT.usage);
+	}
+};
+const askFile = async (ctx, path, flags) => {
+	const { io } = ctx;
+	const parsed = askFileSchema.safeParse(await readDataFile(path, "questions file"));
+	if (!parsed.success) throw new CliError(`The questions file has problems:\n    ${describeIssues(parsed.error)}`, EXIT.usage);
+	const file = parsed.data;
+	if (flags.maxLatency !== void 0 && (!Number.isInteger(flags.maxLatency) || flags.maxLatency < 200 || flags.maxLatency > 12e4)) throw new CliError("--max-latency is a whole number of milliseconds, from 200 to 120000.", EXIT.usage);
+	let state = file.state;
+	if (state !== void 0 && (flags.text !== void 0 || flags.file !== void 0)) throw new CliError("The file already has a state. Leave out --text and --file, or remove state from the file.", EXIT.usage);
+	state ??= await readState(flags, io);
+	checkStateLength(state);
+	const reasoning = flags.reasoning ?? file.reasoning;
+	const maxLatency = flags.maxLatency ?? file.max_latency_ms;
+	const request = {
+		state,
+		questions: file.questions,
+		...reasoning && { reasoning },
+		...maxLatency !== void 0 && { max_latency_ms: maxLatency }
+	};
+	if (flags.dryRun) {
+		writeJson(io, request);
+		if (io.stderr.isTTY) io.stderr.write(`  ${ctx.err("dim", "Dry run: nothing was sent.")}\n`);
+		return EXIT.ok;
+	}
+	const langs = codeLangs(flags.code);
+	if (langs) {
+		printCode(ctx, langs, systemOneTs(request, ctx.baseURL), curl("/v1/systemone", request, ctx.baseURL));
+		return EXIT.ok;
+	}
+	const { res, totalMs } = await sendSystemOne(ctx, request);
+	if (flags.field !== void 0) {
+		const [name = "", ...rest] = flags.field.split(".");
+		const answer = res.answers[name];
+		if (!answer) throw new CliError(`There's no question named "${clean(name)}".`, EXIT.usage, `Questions: ${Object.keys(res.answers).join(", ")}`);
+		io.stdout.write(`${rest.length > 0 ? pickField(answer, rest.join(".")) : JSON.stringify(answer)}\n`);
+	} else if (flags.json || !io.stdout.isTTY) writeJson(io, res);
+	else {
+		const p = ctx.out;
+		const lines = [""];
+		for (const [name, question] of Object.entries(file.questions)) {
+			const answer = res.answers[name];
+			if (!answer) continue;
+			lines.push(`  ${p("dim", clean(name))}  ${p("bold", clean(question.instructions))}`, "");
+			lines.push(...renderAnswer(answer, p, io.stdout.columns), "");
+		}
+		lines.push(renderFooter(res, totalMs, p), "");
+		io.stdout.write(`${lines.join("\n")}\n`);
+	}
+	return EXIT.ok;
+};
+//#endregion
+//#region src/commands/doctor.ts
+/** A CliError becomes a failed check. Anything else is a bug and is thrown. */
+const attempt = async (name, run) => {
+	try {
+		return await run();
+	} catch (err) {
+		if (!(err instanceof CliError) || err.code === EXIT.cancelled) throw err;
+		return {
+			name,
+			state: "fail",
+			detail: err.message,
+			hint: err.hint
+		};
+	}
+};
+const doctor = async (ctx, opts) => {
+	const { io } = ctx;
+	const pretty = !opts.json && Boolean(io.stdout.isTTY);
+	const p = ctx.out;
+	const results = [];
+	const show = (result) => {
+		results.push(result);
+		if (!pretty) return;
+		const mark = result.state === "ok" ? p("green", "✓") : result.state === "fail" ? p("red", "✗") : p("dim", "–");
+		io.stdout.write(`  ${mark} ${result.name.padEnd(15)} ${result.state === "skip" ? p("dim", result.detail) : result.detail}\n`);
+		if (result.hint) io.stdout.write(`    ${" ".repeat(15)} ${p("dim", result.hint)}\n`);
+	};
+	if (pretty) io.stdout.write(`\n  ${p("bold", "Wity doctor")}\n\n`);
+	show({
+		name: "Node.js",
+		state: "ok",
+		detail: process.versions.node
+	});
+	show({
+		name: "API address",
+		state: "ok",
+		detail: ctx.baseURL === "https://wity-proxy-production-2c33.up.railway.app" ? ctx.baseURL : `${ctx.baseURL} (custom)`
+	});
+	show(await attempt("Key storage", async () => {
+		return {
+			name: "Key storage",
+			state: "ok",
+			detail: (await ctx.store()).location
+		};
+	}));
+	const health = await attempt("Wity reachable", async () => {
+		const check = await checkHealth(ctx.baseURL, io);
+		return check.status === 200 ? {
+			name: "Wity reachable",
+			state: "ok",
+			detail: `answered in ${ms(check.ms)}`
+		} : {
+			name: "Wity reachable",
+			state: "fail",
+			detail: `the health check answered ${check.status}`
+		};
+	});
+	show(health);
+	let found;
+	/** No key, or a key Wity refused. Exits with the auth code, so scripts can tell it from a network problem. */
+	let authProblem = false;
+	show(await attempt("API key", async () => {
+		found = await findKey(ctx.baseURL, io.env, ctx.store);
+		authProblem = !found;
+		return found ? {
+			name: "API key",
+			state: "ok",
+			detail: `${keyPrefix(found.key)} from ${found.location}`
+		} : {
+			name: "API key",
+			state: "fail",
+			detail: "no key found",
+			hint: "Run `wity api-key set`, or set WITY_API_KEY."
+		};
+	}));
+	const using = found;
+	show(using && health.state === "ok" ? await attempt("Key accepted", async () => {
+		const check = await checkKey(using.key, ctx.baseURL, io);
+		authProblem = check.status === 401;
+		return check.status === 200 ? {
+			name: "Key accepted",
+			state: "ok",
+			detail: `yes, checked in ${ms(check.ms)}`
+		} : check.status === 401 ? {
+			name: "Key accepted",
+			state: "fail",
+			detail: "no, Wity refused it",
+			hint: refusedHint(using)
+		} : {
+			name: "Key accepted",
+			state: "fail",
+			detail: `couldn't tell, Wity answered ${check.status}`
+		};
+	}) : {
+		name: "Key accepted",
+		state: "skip",
+		detail: "skipped"
+	});
+	const failed = results.filter((result) => result.state === "fail");
+	if (opts.json || !io.stdout.isTTY) writeJson(io, {
+		ok: failed.length === 0,
+		checks: results
+	});
+	else io.stdout.write(`\n  ${failed.length === 0 ? p("green", "All good.") : p("red", `${failed.length} check${failed.length > 1 ? "s" : ""} failed.`)}\n\n`);
+	if (failed.length === 0) return EXIT.ok;
+	if (authProblem) return EXIT.auth;
+	return EXIT.error;
+};
+//#endregion
+//#region src/commands/generate.ts
+/** State is optional here: some instructions need no input. Empty stdin means none. */
+const readOptionalState = async (flags, ctx) => {
+	if (flags.text !== void 0 || flags.file !== void 0) return readState(flags, ctx.io);
+	if (ctx.io.stdin.isTTY) return void 0;
+	const piped = await readStdin(ctx.io.stdin);
+	if (piped.trim() === "") return void 0;
+	checkStateLength(piped);
+	return piped;
+};
+const footer = (res, totalMs, paint) => `  ${paint("dim", [
+	clean(res.model),
+	`${ms(res.metadata.elapsed_ms)} on Wity`,
+	`${ms(totalMs)} total`,
+	`${res.usage.input_tokens.toLocaleString("en")} input tokens`,
+	`${res.usage.output_tokens.toLocaleString("en")} written (free)`,
+	`≈ ${cost(res.usage.input_tokens)}`
+].join(" · "))}`;
+const generate = async (ctx, instructions, flags) => {
+	const { io } = ctx;
+	if (instructions.trim() === "") throw new CliError("The instructions are empty.", EXIT.usage);
+	if (flags.maxTokens !== void 0 && (!Number.isInteger(flags.maxTokens) || flags.maxTokens < 1 || flags.maxTokens > 512)) throw new CliError("--max-tokens is a whole number from 1 to 512.", EXIT.usage);
+	let shape;
+	if (flags.shape !== void 0) {
+		const data = await readDataFile(flags.shape, "shape file");
+		if (typeof data !== "object" || data === null || Array.isArray(data) || data.type !== "object") throw new CliError("The shape must be a JSON Schema with \"type\": \"object\" at the top.", EXIT.usage);
+		shape = data;
+	}
+	const state = await readOptionalState(flags, ctx);
+	const request = {
+		...state !== void 0 && { state },
+		instructions,
+		...shape && { shape },
+		...flags.maxTokens !== void 0 && { max_tokens: flags.maxTokens }
+	};
+	if (flags.dryRun) {
+		writeJson(io, request);
+		if (io.stderr.isTTY) io.stderr.write(`  ${ctx.err("dim", "Dry run: nothing was sent.")}\n`);
+		return EXIT.ok;
+	}
+	const langs = codeLangs(flags.code);
+	if (langs) {
+		printCode(ctx, langs, generateTs(request, ctx.baseURL), curl("/v1/generate", request, ctx.baseURL));
+		return EXIT.ok;
+	}
+	const { res, totalMs } = await sendGenerate(ctx, request);
+	const cutOff = res.finish_reason === "length";
+	if (flags.json) writeJson(io, res);
+	else if (!io.stdout.isTTY) {
+		if (shape) {
+			if (res.value == null) throw new CliError("Wity was cut off before the JSON was complete.", EXIT.error, "Raise --max-tokens.");
+			io.stdout.write(`${JSON.stringify(res.value)}\n`);
+		} else io.stdout.write(`${cleanBlock(res.text)}\n`);
+	} else {
+		const p = ctx.out;
+		const lines = [
+			"",
+			...(shape && res.value != null ? JSON.stringify(res.value, null, 2) : cleanBlock(res.text)).split("\n").map((line) => `  ${line}`),
+			""
+		];
+		if (cutOff) lines.push(`  ${p("yellow", `▲ Cut off at ${flags.maxTokens ?? 128} tokens. Raise --max-tokens for the rest.`)}`, "");
+		lines.push(footer(res, totalMs, p), "");
+		io.stdout.write(`${lines.join("\n")}\n`);
+	}
+	if (cutOff && !flags.json && !io.stdout.isTTY) io.stderr.write(`  ${ctx.err("yellow", "▲")} Cut off at max tokens. Raise --max-tokens for the rest.\n`);
+	if (cutOff && shape && res.value == null) return EXIT.error;
+	return EXIT.ok;
+};
+//#endregion
+//#region src/context.ts
+const makeCtx = (io, baseUrlFlag) => {
+	const baseURL = resolveBaseURL(baseUrlFlag, io.env);
+	let opened;
+	return {
+		io,
+		baseURL,
+		store: () => {
+			opened ??= openStore(io.env);
+			return opened;
+		},
+		out: painter(shouldColor(io.env, io.stdout)),
+		err: painter(shouldColor(io.env, io.stderr))
+	};
+};
+//#endregion
+//#region src/main.ts
+const number = (value) => {
+	const parsed = Number(value);
+	if (value.trim() === "" || !Number.isFinite(parsed)) throw new InvalidArgumentError("Not a number.");
+	return parsed;
+};
+const collect = (value, previous = []) => [...previous, value];
+const askOptions = (command) => command.option("-t, --text <text>", "the text to judge").option("--file <path>", "read the text from a file (- for stdin)").addOption(new Option("-r, --reasoning <mode>", "when Wity thinks before answering").choices([
+	"off",
+	"auto",
+	"always"
+])).option("--max-latency <ms>", "cap the time per request, 200 to 120000 ms", number).option("--fail-under <n>", "exit with code 10 if the answer is under n", number).option("--field <path>", "print one field of the answer, like noul or probabilities.billing").option("--json", "print the full response as JSON (the default when piped)").option("--dry-run", "print the request without sending it").option("--code [lang]", "print the request as TypeScript and curl (or only ts, or curl) instead of sending it");
+const EXAMPLES = `
+Examples:
+  cat email.txt | wity noul "Is this spam?"
+  wity choice "Which team handles this?" -o billing="Payments and refunds" -o tech="Bugs" --file ticket.txt
+  wity score "How upset is the customer?" -l Calm -l Annoyed -l Angry --text "Where is my order?!"
+  wity noul "Is this safe to merge?" --file diff.txt --fail-under 0.8 && git merge
+  wity ask questions.yaml --file ticket.txt
+  wity generate "A one-line reply to this customer" --file ticket.txt
+
+Exit codes:
+  0 ok · 1 API or network error · 2 bad input (not billed) · 3 no API key, or the key was refused
+  10 answered, but failed --fail-under or --expect · 130 cancelled
+`;
+const main = async (argv, io) => {
+	let code = EXIT.ok;
+	const program = new Command("wity");
+	const ctx = () => makeCtx(io, program.opts().baseUrl);
+	program.description("Ask Wity typed questions about any text, and get a probability for every answer.").version(version, "-v, --version", "print the version").helpOption("-h, --help", "show help").helpCommand("help [command]", "show help for a command").addOption(new Option("--base-url <url>", "API address (default: WITY_BASE_URL, then the Wity API)").hideHelp()).addHelpText("after", EXAMPLES).showHelpAfterError("(add --help for usage)").configureOutput({
+		writeOut: (text) => io.stdout.write(text),
+		writeErr: (text) => io.stderr.write(text),
+		outputError: (text, write) => write(text.replace(/wity_[\w-]{16,}/g, "wity_…"))
+	}).exitOverride().action(async () => {
+		if (!io.stdin.isTTY || !io.stdout.isTTY) program.help();
+		const { playground } = await import("./playground-Cn7EIrd7.mjs");
+		code = await playground(ctx(), "");
+	});
+	const setHint = "Run `wity api-key set <key>`, or `wity api-key set` to paste it at a hidden prompt.";
+	const keyCommand = program.command("api-key").description("save, show or remove your Wity API key").allowExcessArguments().allowUnknownOption().action((_opts, command) => {
+		if (command.args.length > 0) throw new CliError("`wity api-key` takes set, show or remove.", EXIT.usage, setHint);
+		command.help();
+	});
+	keyCommand.command("set").description("save an API key: give it here, or paste it at a hidden prompt").argument("[key]", "the API key (leave out to paste it at a prompt)").option("--stdin", "read the key from stdin, for CI and scripts").allowExcessArguments().allowUnknownOption().action(async (_key, opts, command) => {
+		const [key, ...rest] = command.args;
+		if (rest.length > 0 || key?.startsWith("-")) throw new CliError("`wity api-key set` takes only the key.", EXIT.usage, setHint);
+		code = await setKey(ctx(), opts, key);
+	});
+	keyCommand.command("show").description("show which key is in use, and check that it works").option("--json", "print as JSON").action(async (opts) => {
+		code = await showKey(ctx(), opts);
+	});
+	keyCommand.command("remove").description("remove the saved key from this computer").action(async () => {
+		code = await removeKey(ctx());
+	});
+	program.command("doctor").description("check the setup: key, storage, and the connection to Wity").option("--json", "print as JSON").action(async (opts) => {
+		code = await doctor(ctx(), opts);
+	});
+	askOptions(program.command("noul").description("ask a yes or no question. Prints the probability of yes").argument("<question>", "the question, like \"Is this spam?\"").option("--if-yes <text>", "what yes means (use with --if-no)").option("--if-no <text>", "what no means (use with --if-yes)")).action(async (question, opts) => {
+		code = await ask(ctx(), noulQuestion(question, opts.ifYes, opts.ifNo), opts);
+	});
+	askOptions(program.command("choice").description("pick one of several options. Prints a probability for each").argument("<question>", "the question, like \"Which team should handle this?\"").requiredOption("-o, --option <id=description>", "an option, repeat for each (2 to 256)", collect).option("--expect <id>", "exit with code 10 unless this option wins (or, with --fail-under, is at least n)")).action(async (question, opts) => {
+		code = await ask(ctx(), choiceQuestion(question, opts.option), opts, { expect: opts.expect });
+	});
+	askOptions(program.command("score").description("place the text on a scale of 2 to 10 levels").argument("<question>", "the question, like \"How upset is the customer?\"").requiredOption("-l, --level <text>", "a level, lowest first, repeat for each (2 to 10)", collect)).action(async (question, opts) => {
+		code = await ask(ctx(), scoreQuestion(question, opts.level), opts);
+	});
+	program.command("ask").description("ask several named questions about one text, from a YAML or JSON file").argument("<questions-file>", "the questions, in the API's shape (see README)").option("-t, --text <text>", "the text to judge (unless the file has a state)").option("--file <path>", "read the text from a file (- for stdin)").addOption(new Option("-r, --reasoning <mode>", "when Wity thinks before answering").choices([
+		"off",
+		"auto",
+		"always"
+	])).option("--max-latency <ms>", "cap the time per request, 200 to 120000 ms", number).option("--field <path>", "print one value, like team.choice or urgent.noul").option("--json", "print the full response as JSON (the default when piped)").option("--dry-run", "print the request without sending it").option("--code [lang]", "print the request as TypeScript and curl (or only ts, or curl) instead of sending it").action(async (path, opts) => {
+		code = await askFile(ctx(), path, opts);
+	});
+	program.command("generate").description("write short text, or JSON that matches a shape").argument("<instructions>", "what to write, like \"A one-line reply to this customer\"").option("-t, --text <text>", "the text to write from (optional)").option("--file <path>", "read the text from a file (- for stdin)").option("--shape <file>", "a JSON Schema (JSON or YAML) the output must match").option("--max-tokens <n>", "the most tokens to write, 1 to 512 (default 128)", number).option("--json", "print the full response as JSON").option("--dry-run", "print the request without sending it").option("--code [lang]", "print the request as TypeScript and curl (or only ts, or curl) instead of sending it").action(async (instructions, opts) => {
+		code = await generate(ctx(), instructions, opts);
+	});
+	program.command("playground").description("try questions live in the terminal (also: wity with no arguments)").option("-t, --text <text>", "start with this text").option("--file <path>", "start with the text of this file").action(async (opts) => {
+		const text = opts.text !== void 0 || opts.file !== void 0 ? await readState(opts, io) : "";
+		const { playground } = await import("./playground-Cn7EIrd7.mjs");
+		code = await playground(ctx(), text);
+	});
+	program.command("mcp").description("run Wity as an MCP server for AI agents").command("serve").description("serve Wity's tools over stdio, for Claude Code, Claude Desktop, Cursor and others").option("--max-spend <usd>", "stop paid calls after this many dollars in one session", number).action(async (opts) => {
+		const { serveMcp } = await import("./mcp-DnqXX8ba.mjs");
+		code = await serveMcp(ctx(), opts);
+	});
+	try {
+		await program.parseAsync(argv, { from: "user" });
+		return code;
+	} catch (err) {
+		if (err instanceof CommanderError) return err.exitCode === 0 ? EXIT.ok : EXIT.usage;
+		const paint = painter(shouldColor(io.env, io.stderr));
+		if (err instanceof CliError) {
+			io.stderr.write(`\n  ${paint("red", "✗")} ${err.message}\n`);
+			if (err.hint) io.stderr.write(`    ${paint("dim", err.hint)}\n`);
+			io.stderr.write("\n");
+			return err.code;
+		}
+		const message = err instanceof Error ? err.message : String(err);
+		io.stderr.write(`\n  ${paint("red", "✗")} Something went wrong: ${clean(message)}\n\n`);
+		return EXIT.error;
+	}
+};
+//#endregion
+//#region src/cli.ts
+const controller = new AbortController();
+process.on("SIGINT", () => {
+	process.stderr.write("\x1B[?25h");
+	controller.abort();
+	setTimeout(() => process.exit(130), 500).unref();
+});
+process.stdout.on("error", (err) => {
+	if (err.code === "EPIPE") process.exit(process.exitCode ?? 0);
+	throw err;
+});
+process.exitCode = await main(process.argv.slice(2), processIo(controller.signal));
+//#endregion
+export {};