wity-cli 0.1.0

package/dist/questions-eZ01WB1q.mjs

@@ -0,0 +1,325 @@
+import { A as truncate, B as score, C as cost, D as pct, F as CliError, I as EXIT, R as choice, T as ms, b as bar, j as writeJson, r as sendSystemOne, u as readState, w as decimal, x as clean, z as noul } from "./send-CGXuVi9Z.mjs";
+//#region src/code.ts
+/** A string as a JavaScript literal. JSON's escaping is valid JavaScript, and safe for any text. */
+const str = (value) => JSON.stringify(value);
+/** An object key: bare when it's a plain identifier, quoted otherwise. */
+const prop = (key) => /^[A-Za-z_$][\w$]*$/.test(key) ? key : str(key);
+/** A JSON value as JavaScript, indented to sit at `indent`. */
+const literal = (value, indent) => JSON.stringify(value, null, 2).split("\n").map((line, i) => i === 0 ? line : indent + line).join("\n").replace(/^(\s*)"([A-Za-z_$][\w$]*)":/gm, "$1$2:");
+const builder = (question, indent) => {
+	if (question.type === "noul") return question.criteria ? `noul(${str(question.instructions)}, ${literal(question.criteria, indent)})` : `noul(${str(question.instructions)})`;
+	if (question.type === "choice") {
+		const options = Object.entries(question.criteria).map(([id, description]) => `${indent}  ${prop(id)}: ${str(description)},`).join("\n");
+		return `choice(${str(question.instructions)}, {\n${options}\n${indent}})`;
+	}
+	const levels = question.criteria.map(str);
+	const inline = `[${levels.join(", ")}]`;
+	return inline.length <= 80 ? `score(${str(question.instructions)}, ${inline})` : `score(${str(question.instructions)}, [\n${levels.map((level) => `${indent}  ${level},`).join("\n")}\n${indent}])`;
+};
+const clientLine = (baseURL) => baseURL === "https://wity-proxy-production-2c33.up.railway.app" ? "const client = new WityClient(); // reads WITY_API_KEY" : `const client = new WityClient({ baseURL: ${str(baseURL)} }); // reads WITY_API_KEY`;
+const systemOneTs = (request, baseURL) => {
+	const types = [...new Set(Object.values(request.questions).map((q) => q.type))].sort();
+	const questions = Object.entries(request.questions).map(([name, question]) => `    ${prop(name)}: ${builder(question, "    ")},`).join("\n");
+	const extras = [request.reasoning && `  reasoning: ${str(request.reasoning)},`, request.max_latency_ms !== void 0 && `  max_latency_ms: ${request.max_latency_ms},`].filter(Boolean);
+	const first = Object.entries(request.questions)[0];
+	const field = first?.[1].type === "noul" ? "noul" : first?.[1].type === "choice" ? "choice" : "score";
+	return [
+		`import { WityClient, ${types.join(", ")} } from "wity-sdk";`,
+		"",
+		clientLine(baseURL),
+		"",
+		"const res = await client.systemOne({",
+		`  state: ${literal(request.state, "  ")},`,
+		"  questions: {",
+		questions,
+		"  },",
+		...extras,
+		"});",
+		"",
+		first ? `console.log(res.answers.${prop(first[0])}.${field});` : "console.log(res.answers);"
+	].join("\n");
+};
+const generateTs = (request, baseURL) => {
+	const fields = [
+		request.state !== void 0 && `  state: ${literal(request.state, "  ")},`,
+		`  instructions: ${str(request.instructions)},`,
+		request.shape !== void 0 && `  shape: ${literal(request.shape, "  ")},`,
+		request.max_tokens !== void 0 && `  max_tokens: ${request.max_tokens},`
+	].filter(Boolean);
+	return [
+		`import { WityClient } from "wity-sdk";`,
+		"",
+		clientLine(baseURL),
+		"",
+		"const res = await client.generate({",
+		...fields,
+		"});",
+		"",
+		request.shape !== void 0 ? "console.log(res.value);" : "console.log(res.text);"
+	].join("\n");
+};
+/**
+* A curl command. The body goes in a quoted heredoc, so the shell never expands anything in it.
+* JSON strings can't hold a raw line break, so no line of the body can end the heredoc early.
+*/
+const curl = (route, body, baseURL) => [
+	`curl ${baseURL}${route} \\`,
+	`  -H "Authorization: Bearer $WITY_API_KEY" \\`,
+	`  -H "Content-Type: application/json" \\`,
+	"  -d @- <<'JSON'",
+	JSON.stringify(body, null, 2),
+	"JSON"
+].join("\n");
+/** `--code`, `--code ts` or `--code curl`. Commander gives `true` for the bare flag. */
+const codeLangs = (value) => {
+	if (value === void 0 || value === false) return void 0;
+	if (value === true) return ["ts", "curl"];
+	if (value === "ts" || value === "curl") return [value];
+	throw new CliError("--code takes ts or curl, or nothing for both.", EXIT.usage);
+};
+const printCode = (ctx, langs, ts, sh) => {
+	const { io } = ctx;
+	const pretty = Boolean(io.stdout.isTTY);
+	const show = (title, code) => {
+		if (pretty) io.stdout.write(`\n  ${ctx.out("dim", title)}\n\n`);
+		io.stdout.write(`${code}\n`);
+	};
+	if (langs.includes("ts")) show("TypeScript · npm install wity-sdk", ts);
+	if (langs.includes("curl")) show("curl", sh);
+	if (pretty) io.stdout.write(`\n  ${ctx.out("dim", "Nothing was sent. Set WITY_API_KEY before running this.")}\n\n`);
+};
+//#endregion
+//#region src/render.ts
+/** Choice answers with more options than this show the top ones, and say how many are hidden. */
+const MAX_ROWS = 10;
+const MAX_LABEL = 28;
+const barWidth = (columns) => columns !== void 0 && columns < 72 ? 14 : 28;
+const rows = (items, paint, columns) => {
+	const width = barWidth(columns);
+	const labelWidth = Math.max(...items.map((row) => row.label.length));
+	const tagWidth = Math.max(0, ...items.map((row) => row.tag?.length ?? 0));
+	return items.map((row) => {
+		const mark = row.winner ? paint("green", "●") : " ";
+		const tag = row.tag !== void 0 ? `${paint("dim", row.tag.padStart(tagWidth))}  ` : "";
+		const label = row.label.padEnd(labelWidth);
+		const value = pct(row.p).padStart(7);
+		return `  ${mark} ${tag}${row.winner ? paint("bold", label) : label}  ${bar(row.p, width, paint, row.winner ? "green" : "gray")}  ${row.winner ? paint("bold", value) : paint("dim", value)}`;
+	});
+};
+const REASONS = {
+	close_call: "the top options were close",
+	order_sensitive: "the answer changed when the options were reordered",
+	forecast: "the question asks for a likelihood",
+	requested: "reasoning was set to always"
+};
+/** A note when Wity thought before answering, with the answer it had before thinking. */
+const thinking = (info, before, paint) => {
+	const lines = [];
+	if (info?.thought) {
+		const why = info.reason ? REASONS[info.reason] ?? clean(info.reason).replaceAll("_", " ") : void 0;
+		const tokens = info.thought_tokens ? ` ${info.thought_tokens.toLocaleString("en")} thought tokens.` : "";
+		lines.push(`  ${paint("magenta", "◆")} ${paint("dim", `Wity thought first${why ? `, because ${why}` : ""}.${tokens}`)}`);
+		if (before) lines.push(`    ${paint("dim", `Before thinking: ${before}`)}`);
+	}
+	if (info?.budget_limited) lines.push(`  ${paint("yellow", "▲ Thinking was cut short to meet --max-latency.")}`);
+	return lines;
+};
+const topOf = (probabilities) => Object.entries(probabilities).reduce((best, entry) => entry[1] > best[1] ? entry : best, ["", -1])[0];
+const renderNoul = (answer, paint, columns) => {
+	const yes = answer.noul;
+	const lines = rows([{
+		label: "yes",
+		p: yes,
+		winner: yes >= .5
+	}, {
+		label: "no",
+		p: 1 - yes,
+		winner: yes < .5
+	}], paint, columns);
+	const before = answer.direct_noul !== void 0 ? `yes ${pct(answer.direct_noul)}` : void 0;
+	return [...lines, ...spaced(thinking(answer.reasoning, before, paint))];
+};
+const renderChoice = (answer, paint, columns) => {
+	const sorted = Object.entries(answer.probabilities).sort((a, b) => b[1] - a[1]);
+	const shown = sorted.slice(0, MAX_ROWS);
+	const lines = rows(shown.map(([id, p]) => ({
+		label: truncate(clean(id), MAX_LABEL),
+		p,
+		winner: id === answer.choice
+	})), paint, columns);
+	if (sorted.length > shown.length) lines.push(`    ${paint("dim", `and ${sorted.length - shown.length} more options. Use --json to see all.`)}`);
+	lines.push("", `  ${paint("dim", `confidence ${decimal(answer.confidence)}`)}`);
+	const direct = answer.direct_probabilities;
+	const top = direct && topOf(direct);
+	const before = direct && top ? `${truncate(clean(top), MAX_LABEL)} ${pct(direct[top] ?? 0)}` : void 0;
+	return [...lines, ...spaced(thinking(answer.reasoning, before, paint))];
+};
+const renderScore = (answer, paint, columns) => {
+	const levels = Object.keys(answer.legend).sort((a, b) => Number(a) - Number(b));
+	const top = topOf(answer.probabilities);
+	const name = (level) => truncate(clean(answer.legend[level ?? ""] ?? ""), MAX_LABEL);
+	const low = levels[0];
+	const high = levels[levels.length - 1];
+	const head = `  ${paint("bold", answer.score.toFixed(2))}  ${paint("dim", `on a scale from ${low} (${name(low)}) to ${high} (${name(high)})`)}`;
+	const lines = rows(levels.map((level) => ({
+		tag: level,
+		label: name(level),
+		p: answer.probabilities[level] ?? 0,
+		winner: level === top
+	})), paint, columns);
+	const direct = answer.direct_probabilities;
+	const before = direct ? `score ${Object.entries(direct).reduce((sum, [level, p]) => sum + Number(level) * p, 0).toFixed(2)}` : void 0;
+	return [
+		head,
+		"",
+		...lines,
+		"",
+		`  ${paint("dim", `confidence ${decimal(answer.confidence)}`)}`,
+		...spaced(thinking(answer.reasoning, before, paint))
+	];
+};
+/** Any answer, by its type. */
+const renderAnswer = (answer, paint, columns) => answer.type === "noul" ? renderNoul(answer, paint, columns) : answer.type === "choice" ? renderChoice(answer, paint, columns) : renderScore(answer, paint, columns);
+/** A blank line before a block, if there is a block. */
+const spaced = (lines) => lines.length > 0 ? ["", ...lines] : [];
+/** The last line: model, time on Wity, total time, tokens and estimated cost. */
+const renderFooter = (res, totalMs, paint) => {
+	return `  ${paint("dim", [
+		clean(res.model),
+		`${ms(res.metadata.elapsed_ms)} on Wity`,
+		`${ms(totalMs)} total`,
+		`${res.usage.input_tokens.toLocaleString("en")} input tokens`,
+		`≈ ${cost(res.usage.input_tokens)}`
+	].join(" · "))}`;
+};
+//#endregion
+//#region src/commands/questions.ts
+/** Answers come back under the question's name. A single question is always called this. */
+const NAME = "answer";
+const needText = (value, what) => {
+	if (value.trim() === "") throw new CliError(`The ${what} is empty.`, EXIT.usage);
+	return value;
+};
+/** `--option id=description`, or just `--option id` when the id says enough. */
+const choiceQuestion = (instructions, options) => {
+	if (options.length < 2 || options.length > 256) throw new CliError(`A choice needs 2 to 256 options. You gave ${options.length}.`, EXIT.usage, "Add each with --option id=\"description\".");
+	const criteria = {};
+	for (const option of options) {
+		const at = option.indexOf("=");
+		const id = (at === -1 ? option : option.slice(0, at)).trim();
+		const description = (at === -1 ? option : option.slice(at + 1)).trim();
+		if (!id) throw new CliError(`The option "${clean(option)}" has no id before the =.`, EXIT.usage);
+		if (id in criteria) throw new CliError(`The option id "${clean(id)}" is used twice.`, EXIT.usage);
+		criteria[id] = description || id;
+	}
+	return choice(needText(instructions, "question"), criteria);
+};
+const noulQuestion = (instructions, yes, no) => {
+	if (yes === void 0 !== (no === void 0)) throw new CliError("Describe both answers, with --yes and --no, or neither.", EXIT.usage);
+	const text = needText(instructions, "question");
+	return yes !== void 0 && no !== void 0 ? noul(text, {
+		true: yes,
+		false: no
+	}) : noul(text);
+};
+const scoreQuestion = (instructions, levels) => {
+	if (levels.length < 2 || levels.length > 10) throw new CliError(`A score needs 2 to 10 levels. You gave ${levels.length}.`, EXIT.usage, "Add each with --level, lowest first.");
+	levels.forEach((level) => {
+		needText(level, "level");
+	});
+	return score(needText(instructions, "question"), levels);
+};
+/** Checked before the call, so a mistake costs nothing. */
+const checkGate = (question, gate) => {
+	const { failUnder, expect } = gate;
+	if (expect !== void 0 && question.type === "choice" && !(expect in question.criteria)) throw new CliError(`--expect "${clean(expect)}" isn't one of the options.`, EXIT.usage);
+	if (failUnder === void 0) return;
+	if (question.type === "score") {
+		const top = question.criteria.length - 1;
+		if (failUnder < 0 || failUnder > top) throw new CliError(`For a score, --fail-under is a level from 0 to ${top}.`, EXIT.usage);
+	} else if (failUnder < 0 || failUnder > 1) throw new CliError("--fail-under is a probability from 0 to 1.", EXIT.usage);
+};
+/** `undefined` when it passes, or the reason it failed. */
+const failedGate = (answer, gate) => {
+	const { failUnder, expect } = gate;
+	if (answer.type === "noul") {
+		if (failUnder !== void 0 && answer.noul < failUnder) return `yes is ${pct(answer.noul)}, under --fail-under ${failUnder}.`;
+		return;
+	}
+	if (answer.type === "score") {
+		if (failUnder !== void 0 && answer.score < failUnder) return `The score is ${answer.score.toFixed(2)}, under --fail-under ${failUnder}.`;
+		return;
+	}
+	const option = expect ?? answer.choice;
+	const p = answer.probabilities[option] ?? 0;
+	if (failUnder !== void 0) return p < failUnder ? `${clean(option)} is ${pct(p)}, under --fail-under ${failUnder}.` : void 0;
+	if (expect !== void 0 && answer.choice !== expect) return `Wity chose ${clean(answer.choice)}, not ${clean(expect)}.`;
+};
+/** A value inside the answer, by dotted path: `noul`, `choice`, `probabilities.billing`, `reasoning.thought`. */
+const pickField = (answer, path) => {
+	let value = answer;
+	for (const part of path.split(".")) {
+		if (typeof value !== "object" || value === null || !Object.hasOwn(value, part)) {
+			const fields = Object.keys(answer).join(", ");
+			throw new CliError(`The answer has no field "${clean(path)}".`, EXIT.usage, `Fields: ${fields}`);
+		}
+		value = value[part];
+	}
+	if (typeof value === "string") return clean(value);
+	if (typeof value === "object" && value !== null) return JSON.stringify(value);
+	return String(value);
+};
+const ask = async (ctx, question, flags, gate = {}) => {
+	const { io } = ctx;
+	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);
+	checkGate(question, {
+		failUnder: flags.failUnder,
+		...gate
+	});
+	const allGates = {
+		failUnder: flags.failUnder,
+		...gate
+	};
+	const request = {
+		state: await readState(flags, io),
+		questions: { [NAME]: question },
+		...flags.reasoning && { reasoning: flags.reasoning },
+		...flags.maxLatency !== void 0 && { max_latency_ms: flags.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);
+	const answer = res.answers[NAME];
+	if (!answer) throw new CliError("Wity's answer was missing the question. Try again.", EXIT.error);
+	if (flags.field !== void 0) io.stdout.write(`${pickField(answer, flags.field)}\n`);
+	else if (flags.json || !io.stdout.isTTY) writeJson(io, res);
+	else {
+		const p = ctx.out;
+		const lines = [
+			"",
+			`  ${p("bold", clean(question.instructions))}`,
+			"",
+			...renderAnswer(answer, p, io.stdout.columns),
+			"",
+			renderFooter(res, totalMs, p),
+			""
+		];
+		io.stdout.write(`${lines.join("\n")}\n`);
+	}
+	const failed = failedGate(answer, allGates);
+	if (failed) {
+		io.stderr.write(`  ${ctx.err("red", "✗")} ${failed}\n`);
+		return EXIT.gate;
+	}
+	return EXIT.ok;
+};
+//#endregion
+export { scoreQuestion as a, codeLangs as c, printCode as d, systemOneTs as f, pickField as i, curl as l, choiceQuestion as n, renderAnswer as o, noulQuestion as r, renderFooter as s, ask as t, generateTs as u };