@krapht/ork 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/output-DXZbnFt_.mjs

@@ -0,0 +1,458 @@
+import { stripVTControlCharacters, styleText } from "node:util";
+import { createInterface } from "node:readline/promises";
+// src/term/theme.ts
+/**
+* @file The terminal kit's one theme: a role says what a piece of text means
+*   (accent, ok, warn, danger, muted), and the theme gives it a look that reads
+*   on dark and light terminals: the 16 ANSI colors only, and a fixed
+*   foreground on every chip background. Nothing is said by color alone: a chip
+*   carries words and a mark a symbol. In plain mode every call returns the
+*   text unstyled.
+*/
+/** The text look of each role. */
+const TEXT = {
+	accent: "cyan",
+	ok: "green",
+	warn: "yellow",
+	danger: "red",
+	muted: "dim"
+};
+/** The chip look of each role: a background and the foreground fixed on it. */
+const CHIP = {
+	accent: ["bgCyan", "black"],
+	ok: ["bgGreen", "black"],
+	warn: ["bgYellow", "black"],
+	danger: ["bgRed", "whiteBright"],
+	muted: ["bgWhite", "black"]
+};
+/** The backgrounds a node chip takes, by a hash of its id. */
+const NODE_PALETTE = [
+	["bgCyan", "black"],
+	["bgGreen", "black"],
+	["bgYellow", "black"],
+	["bgMagenta", "whiteBright"],
+	["bgBlue", "whiteBright"],
+	["bgWhite", "black"]
+];
+/** `text` in `format` when the terminal is rich, else as is. */
+const apply = (term, format, text) => term.rich ? styleText(format, text, { validateStream: false }) : text;
+/** `text` in a role's color. */
+const paint = (term, role, text) => apply(term, TEXT[role], text);
+/** `text` in bold. */
+const bold = (term, text) => apply(term, "bold", text);
+/** Where a line's text starts, after its leading color codes (`ESC[…m`). */
+const textStart = (line) => {
+	let at = 0;
+	while (line.startsWith("\x1B[", at)) {
+		const end = line.indexOf("m", at);
+		if (end === -1) return at;
+		at = end + 1;
+	}
+	return at;
+};
+/** `lines` with the bar in their first column, on a rich terminal. */
+const barred = (t, lines) => {
+	if (!t.rich) return [...lines];
+	const bar = apply(t, "greenBright", "▌");
+	return lines.map((line) => {
+		const at = textStart(line);
+		return line[at] === " " ? `${bar}${line.slice(0, at)}${line.slice(at + 1)}` : line;
+	});
+};
+// src/term/keys.ts
+/** What a `ESC [ …` or `ESC O …` sequence names. */
+const SEQUENCES = {
+	"[A": "up",
+	"[B": "down",
+	"[C": "right",
+	"[D": "left",
+	"[H": "home",
+	"[F": "end",
+	"[1~": "home",
+	"[4~": "end",
+	"[7~": "home",
+	"[8~": "end",
+	"[3~": "delete",
+	OA: "up",
+	OB: "down",
+	OC: "right",
+	OD: "left",
+	OH: "home",
+	OF: "end"
+};
+const CONTROLS = {
+	"\r": "enter",
+	"\n": "enter",
+	"": "backspace",
+	"\b": "backspace",
+	"": "ctrl-c",
+	"": "ctrl-d",
+	"
": "ctrl-a",
+	"": "ctrl-e",
+	"": "ctrl-u"
+};
+/** The keys in one chunk of input; what it does not know it skips. */
+const parseKeys = (chunk) => {
+	const keys = [];
+	const chars = Array.from(chunk);
+	for (let i = 0; i < chars.length; i += 1) {
+		const char = chars[i] ?? "";
+		if (char === "\x1B") {
+			if (i === chars.length - 1) {
+				keys.push({ name: "escape" });
+				continue;
+			}
+			let end = i + (chars[i + 1] === "O" ? 3 : 2);
+			while (chars[i + 1] === "[" && end < chars.length + 1 && !/[A-Za-z~]/u.test(chars[end - 1] ?? "")) end += 1;
+			const name = SEQUENCES[chars.slice(i + 1, end).join("")];
+			if (name !== void 0) keys.push({ name });
+			i = end - 1;
+			continue;
+		}
+		const name = CONTROLS[char];
+		if (name !== void 0) keys.push({ name });
+		else if (char >= " ") keys.push({
+			name: "char",
+			text: char
+		});
+	}
+	return keys;
+};
+/**
+* Reads keys from `input` in raw mode, calling `onKey` for each, until the
+* returned function is called, which restores the mode and pauses the input.
+*/
+const readKeys = (input, onKey) => {
+	const wasRaw = input.isRaw === true;
+	input.setRawMode?.(true);
+	input.resume();
+	const onData = (chunk) => {
+		for (const key of parseKeys(String(chunk))) onKey(key);
+	};
+	input.on("data", onData);
+	return () => {
+		input.off("data", onData);
+		input.setRawMode?.(wasRaw);
+		input.pause();
+	};
+};
+// src/term/layout.ts
+/**
+* @file Layout for plain text: its width, wrapped to a width, cut to one line
+*   with `…`, and hung under a lead. `wrap`, `cut` and `hang` take text before
+*   it is styled (they would cut inside an escape code), so style each piece
+*   after laying it out; `widthOf` and `rowsOf` ignore escape codes. Width
+*   counts one column per code point: wide characters (CJK, emoji) may overrun
+*   a line (specs/gaps.md).
+*/
+/** The columns of `text`, escape codes not counted. */
+const widthOf = (text) => Array.from(stripVTControlCharacters(text)).length;
+/** `text` of one line within `width`, with `…` where it was cut. */
+const cut = (text, width) => {
+	const chars = Array.from(text);
+	return chars.length <= width ? text : `${chars.slice(0, Math.max(0, width - 1)).join("")}…`;
+};
+/** A word that is over `width` is split into pieces of `width`. */
+const pieces = (word, width) => {
+	const chars = Array.from(word);
+	const out = [];
+	for (let i = 0; i < chars.length; i += width) out.push(chars.slice(i, i + width).join(""));
+	return out;
+};
+/**
+* `text` wrapped to lines of at most `width` columns, at spaces; each line
+* break in `text` stays, and a blank line stays blank. A word longer than the
+* width is split.
+*/
+const wrap = (text, width) => text.split("\n").flatMap((paragraph) => {
+	const words = paragraph.split(/ +/u).filter((word) => word !== "");
+	const lines = [];
+	let line = "";
+	for (const word of words.flatMap((w) => pieces(w, width))) if (line === "") line = word;
+	else if (widthOf(line) + 1 + widthOf(word) <= width) line += ` ${word}`;
+	else {
+		lines.push(line);
+		line = word;
+	}
+	lines.push(line);
+	return lines;
+});
+/**
+* `text` wrapped under `lead`: the first line starts with `lead`, the others
+* with spaces as wide as `lead` (a hanging indent), all within `width`.
+*/
+const hang = (lead, text, width) => {
+	const indent = " ".repeat(widthOf(lead));
+	return wrap(text, Math.max(1, width - indent.length)).map((line, index) => (index === 0 ? lead : indent).concat(line));
+};
+/** How many terminal rows `line` takes at `width` (at least one). */
+const rowsOf = (line, width) => Math.max(1, Math.ceil(widthOf(line) / width));
+const DEFAULT_WIDTH = 80;
+const DEFAULT_ROWS = 24;
+/** Whether `ORK_PLAIN` is on: set, and not `0` or `false`. */
+const orkPlain = (value) => value !== void 0 && ![
+	"",
+	"0",
+	"false"
+].includes(value.toLowerCase());
+/** Whether the environment asks for plain output (not the stream). */
+const plainEnv = (env = process.env) => (env["NO_COLOR"] ?? "") !== "" || orkPlain(env["ORK_PLAIN"]) || env["TERM"] === "dumb";
+/** How to write to `stream`, given `env`. */
+const termOf = (stream, env = process.env) => ({
+	rich: stream.isTTY === true && !plainEnv(env),
+	width: Math.max(20, stream.columns ?? DEFAULT_WIDTH),
+	rows: stream.rows ?? DEFAULT_ROWS
+});
+/** Whether a prompt can take keys and redraw: rich output, a raw-mode input. */
+const canKey = (input, output, env = process.env) => termOf(output, env).rich && input.isTTY === true && typeof input.setRawMode === "function";
+/**
+* Takes the global `--plain` flag out of `argv` (up to a `--`, after which
+* words belong to a program). It sets `ORK_PLAIN=1` in `env`, which every child
+* Ork starts then inherits.
+*/
+const takePlainFlag = (argv, env = process.env) => {
+	const end = argv.indexOf("--");
+	const head = end === -1 ? argv : argv.slice(0, end);
+	if (!head.includes("--plain")) return [...argv];
+	env["ORK_PLAIN"] = "1";
+	return [...head.filter((word) => word !== "--plain"), ...argv.slice(head.length)];
+};
+// src/term/line.ts
+/**
+* @file The plain way to ask: one prompt, one line read. It is what every kit
+*   prompt falls back to (not a terminal, `NO_COLOR`, `--plain`), so scripts
+*   and tests that feed lines keep working, and what a screen reader sees.
+*/
+/**
+* Prints `prompt` and reads one line; `undefined` when the input ends first
+* (Ctrl-D, a closed pipe). An aborted `signal` rejects.
+*/
+const readLine = async (io, prompt, signal) => {
+	if (io.readLine !== void 0) return io.readLine(prompt, signal);
+	const rl = createInterface({
+		input: io.input,
+		output: io.output,
+		...plainEnv(io.env) ? { terminal: false } : {}
+	});
+	const { promise: ended, resolve: end } = Promise.withResolvers();
+	rl.once("close", () => {
+		end();
+	});
+	try {
+		const answer = await Promise.race([signal === void 0 ? rl.question(prompt) : rl.question(prompt, { signal }), ended]);
+		return typeof answer === "string" ? answer : void 0;
+	} finally {
+		rl.close();
+	}
+};
+/** Ends a rich prompt on Ctrl-C: the caller's hook, else `SIGINT`. */
+const interrupt = (io) => {
+	if (io.interrupt === void 0) process.kill(process.pid, "SIGINT");
+	else io.interrupt();
+};
+/** The error a withdrawn prompt rejects with: the signal's own, if it is one. */
+const withdrawn = (signal) => signal?.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("the prompt was withdrawn");
+// src/term/screen.ts
+/**
+* @file A redrawn region of the terminal: a prompt draws its lines, and draws
+*   them again, moving the cursor up over its own lines and clearing down,
+*   never the screen. When it is done it leaves one line (or none). The cursor
+*   is hidden while a region is open unless a prompt places it, and is always
+*   restored by {@link Region.finish}. While a region is open, a line another
+*   part of the program prints (a run's transcript, from parallel nodes) goes
+*   through {@link printAbove}, which erases the region, prints the line and
+*   draws the region again, so the rows the region counts stay true.
+*/
+const UP = (n) => n > 0 ? `\u001B[${String(n)}A` : "";
+const CLEAR_DOWN = "\r\x1B[J";
+const HIDE = "\x1B[?25l";
+const SHOW = "\x1B[?25h";
+/** The regions drawn now, the newest last. */
+const open = /* @__PURE__ */ new Set();
+/**
+* Prints `text` above the open region, if one is drawn: `true`, and the caller
+* writes nothing. `false` when no region is open, and the caller writes as
+* usual.
+*/
+const printAbove = (text) => {
+	const region = [...open].at(-1);
+	if (region === void 0) return false;
+	region.above(text);
+	return true;
+};
+/** A region at the cursor of `out`; `term` gives the width, read live. */
+const createRegion = (out, term) => {
+	/** Rows between the cursor and the region's first row. */
+	let up = 0;
+	let last = {
+		lines: [],
+		column: void 0
+	};
+	const erase = () => `${UP(up)}${CLEAR_DOWN}`;
+	const draw = (lines, column) => {
+		open.add(region);
+		const width = term().width;
+		last = {
+			lines,
+			column
+		};
+		const rows = lines.reduce((sum, line) => sum + rowsOf(line, width), 0);
+		const placed = column === void 0 ? HIDE : `${SHOW}\r${column > 0 ? `\u001B[${String(column)}C` : ""}`;
+		out.write(`${erase()}${lines.join("\n")}${placed}`);
+		up = Math.max(0, rows - 1);
+	};
+	const region = {
+		draw,
+		redraw: () => {
+			draw(last.lines, last.column);
+		},
+		above: (text) => {
+			out.write(`${erase()}${text}\n`);
+			up = 0;
+			draw(last.lines, last.column);
+		},
+		finish: (line) => {
+			out.write(`${erase()}${line === void 0 ? "" : `${line}\n`}${SHOW}`);
+			up = 0;
+			last = {
+				lines: [],
+				column: void 0
+			};
+			open.delete(region);
+		}
+	};
+	return region;
+};
+// src/term/confirm.ts
+/**
+* @file The yes-or-no prompt: on a terminal, `Yes` and `No` that ←/→ (or `h`
+*   `l`, Space) move between, `y` and `n` answer at once, Enter takes the one
+*   shown, and Esc is no; it collapses to one line. Plain mode asks `question
+*   [y/N] ` and reads a line: anything but yes is no (the default, for an empty
+*   line), and a closed input is no.
+*/
+/**
+* Asks a yes-or-no question; `null` on Ctrl-C, after the terminal was restored
+* and the interrupt sent, for a caller that must not carry on as if it were
+* no.
+*/
+const confirmOrStop = async (io, options) => {
+	const { question, signal } = options;
+	const fallback = options.default === true;
+	if (signal?.aborted === true) throw withdrawn(signal);
+	if (!canKey(io.input, io.output, io.env)) {
+		const answer = (await readLine(io, `  ${question} ${fallback ? "[Y/n]" : "[y/N]"} `, signal) ?? "").trim().toLowerCase();
+		return answer === "" ? fallback : ["y", "yes"].includes(answer);
+	}
+	const term = () => termOf(io.output, io.env);
+	const region = createRegion(io.output, term);
+	return new Promise((resolve, reject) => {
+		let yes = fallback;
+		const render = () => {
+			const t = term();
+			const asked = hang(" ? ", question, t.width).map((line, i) => i === 0 ? ` ${paint(t, "accent", "?")} ${bold(t, line.slice(3))}` : line);
+			const pick = (label, on) => on ? apply(t, "inverse", ` ${label} `) : ` ${label} `;
+			const keys = paint(t, "muted", "y/n · ←/→ · Enter");
+			region.draw(barred(t, [...asked, `   ${pick("Yes", yes)} ${pick("No", !yes)}  ${keys}`]));
+		};
+		const finish = (answer) => {
+			stop();
+			io.output.off("resize", render);
+			signal?.removeEventListener("abort", onAbort);
+			const t = term();
+			const mark = answer ? paint(t, "ok", "✓") : paint(t, "danger", "✗");
+			region.finish(cut(` ${mark} ${question} · ${answer ? "Yes" : "No"}`, t.width));
+			resolve(answer);
+		};
+		const onAbort = () => {
+			stop();
+			io.output.off("resize", render);
+			region.finish();
+			reject(withdrawn(signal));
+		};
+		const stop = readKeys(io.input, (key) => {
+			if (key.name === "enter") finish(yes);
+			else if (key.name === "escape") finish(false);
+			else if (key.name === "ctrl-c") {
+				stop();
+				io.output.off("resize", render);
+				signal?.removeEventListener("abort", onAbort);
+				region.finish();
+				resolve(null);
+				interrupt(io);
+			} else if (key.name === "left" || key.name === "right") {
+				yes = !yes;
+				render();
+			} else if (key.name === "char") {
+				const c = key.text.toLowerCase();
+				if (c === "y") finish(true);
+				else if (c === "n") finish(false);
+				else if (c === "h" || c === "l" || c === " ") {
+					yes = !yes;
+					render();
+				}
+			}
+		});
+		io.output.on("resize", render);
+		signal?.addEventListener("abort", onAbort, { once: true });
+		render();
+	});
+};
+/** Asks a yes-or-no question; Ctrl-C (after restoring the terminal) is no. */
+const confirm$1 = async (io, options) => await confirmOrStop(io, options) === true;
+// src/output.ts
+/**
+* @file Terminal output helpers: styled text that turns plain when stdout is
+*   not a TTY or `NO_COLOR` is set, and a yes-or-no question on the terminal
+*   (through the terminal kit).
+*/
+/**
+* Styles text for stdout; plain when stdout is not a TTY, `NO_COLOR` is set, or
+* `--plain` (`ORK_PLAIN`) was given. The environment is read on each call:
+* `--plain` is set after the modules load.
+*/
+const style = (format, text) => plainEnv() ? text : styleText(format, text, { stream: process.stdout });
+/**
+* Text from outside, fit for a terminal: escape sequences could hide a line on
+* the very screen a person judges from, and a line break could forge one.
+*/
+const plain = (text) => stripVTControlCharacters(text).replaceAll(/[\p{Cc}\p{Bidi_Control}]/gu, " ");
+/** A line to stdout; above a prompt that is open on the same terminal. */
+const write = (text) => {
+	if (process.stdout.isTTY && printAbove(text)) return;
+	process.stdout.write(`${text}\n`);
+};
+const writeErr = (text) => {
+	if (process.stderr.isTTY && printAbove(text)) return;
+	process.stderr.write(`${text}\n`);
+};
+/** What to run to follow, steer or stop the detached run `id` (ADR-081). */
+const detachHint = (id) => `ork attach ${id} · ork logs ${id} -f · ork tree ${id} · ork decide · ork stop ${id}`;
+/** What a run spent: `$0.0312`, or `$0.00` for nothing. */
+const cost = (usd) => usd === 0 ? "$0.00" : `$${usd.toFixed(4)}`;
+/**
+* A dollar total that misses sessions on a driver with no dollars (RFC-015),
+* said so, with the counted tokens beside it: `$1.2000 (partial) · 3.0k
+* tokens`. A complete total reads as `cost` does.
+*/
+const costOf = (usd, partial, tokens) => {
+	if (partial !== true) return cost(usd);
+	const units = tokens === void 0 ? "" : ` · ${shortCount(tokens)} tokens`;
+	return `${cost(usd)} (partial)${units}`;
+};
+/** `950`, `12.3k`, `1.2M`. */
+const shortCount = (n) => {
+	if (n < 1e3) return String(n);
+	if (n < 1e6) return `${(n / 1e3).toFixed(1)}k`;
+	return `${(n / 1e6).toFixed(1)}M`;
+};
+/**
+* Asks a yes-or-no question on the terminal (stderr), through the kit's confirm
+* prompt; anything but yes is no. A trailing `[y/N]` in `question` is dropped:
+* the prompt adds its own.
+*/
+const confirm = (question) => confirm$1({
+	input: process.stdin,
+	output: process.stderr
+}, { question: question.replace(/\s*\[y\/N\]\s*$/u, "") });
+export { readKeys as C, apply as D, NODE_PALETTE as E, bold as O, wrap as S, CHIP as T, takePlainFlag as _, plain as a, hang as b, write as c, createRegion as d, interrupt as f, plainEnv as g, canKey as h, detachHint as i, paint as k, writeErr as l, withdrawn as m, cost as n, shortCount as o, readLine as p, costOf as r, style as s, confirm as t, confirmOrStop as u, termOf as v, barred as w, widthOf as x, cut as y };

package/dist/outputs-text-CNTJ7Qq_.mjs

@@ -0,0 +1,19 @@
+import { stripVTControlCharacters } from "node:util";
+const OUTPUT_MAX_CHARS = 2e3;
+/** Escapes stripped, other control characters (not line breaks, tabs) blanked. */
+const scrub = (value) => stripVTControlCharacters(value).replaceAll(/[^\P{Cc}\n\t]|\p{Bidi_Control}/gu, " ");
+/**
+* The declared outputs in key order, each scrubbed and cut to
+* {@link OUTPUT_MAX_LINES} lines and {@link OUTPUT_MAX_CHARS} characters; empty
+* when there are none.
+*/
+const outputsText = (outputs) => Object.entries(outputs ?? {}).map(([name, value]) => {
+	const clean = scrub(value.replaceAll("\r\n", "\n")).trimEnd();
+	const text = clean.split("\n").slice(0, 20).join("\n").slice(0, OUTPUT_MAX_CHARS);
+	return {
+		name,
+		text,
+		cut: text.length < clean.length
+	};
+});
+export { outputsText as t };

package/dist/{pause-CL6N_Xrj.mjs → pause-Cl4ZYA35.mjs}

@@ -1,7 +1,8 @@
-import { G as requestContinue, K as requestPause } from "./src-Dujmvv4s.mjs";
-import { t as findRun } from "./find-D6Gj1sxg.mjs";
-import { a as write, c as openStore, i as style, o as writeErr } from "./output-BLQWD6MJ.mjs";
-import { r as continueRefusal } from "./in-a-run-pLAZeNys.mjs";
+import { An as requestContinue, R as openStore, jn as requestPause } from "./src-BuF9Lbow.mjs";
+import { t as findRun } from "./find-Ct5CNl1J.mjs";
+import { c as write, l as writeErr, s as style } from "./output-DXZbnFt_.mjs";
+import { i as continueRefusal } from "./in-a-run-D_wg4iJi.mjs";
+import { t as refuseExtraArguments } from "./extra-arguments-BxQMXARO.mjs";
 import { defineCommand } from "citty";
 // src/commands/pause.ts
 /**
@@ -43,6 +44,7 @@ const pause = defineCommand({
 		name: "pause",
 		description: "Pause a live run, or one node, before its next tool call"
 	},
+	plugins: [refuseExtraArguments],
 	args,
 	run: ({ args: given }) => ask(given.run, (store, run) => requestPause(store, run, void 0, given.node), (run) => given.node === void 0 ? `Run ${run.id} pauses: nothing new starts, and running sessions wait before their next tool call. Go on with: ork continue ${run.id}` : `${given.node} in run ${run.id} pauses before its next tool call. Go on with: ork continue ${run.id} --node ${given.node}`)
 });
@@ -51,6 +53,7 @@ const continueRun = defineCommand({
 		name: "continue",
 		description: "Let a paused run, or one paused node, go on"
 	},
+	plugins: [refuseExtraArguments],
 	args,
 	run: async ({ args: given }) => {
 		const refused = continueRefusal();

package/dist/print-DzugGZQB.mjs

@@ -0,0 +1,19 @@
+import { c as write } from "./output-DXZbnFt_.mjs";
+import { a as refuseIdsWithJson } from "./flags-C90N4J1i.mjs";
+// src/list/print.ts
+/**
+* Prints `rows`: `--ids` their ids (`table.id`) comma-separated; `--json` the
+* rows (or `json(rows)`); else `human(rows)`, which also says what an empty
+* list is. `--ids` with `--json` is refused (said, exit code set).
+*/
+const printList = (rows, table, args, human, json = (shown) => shown) => {
+	if (refuseIdsWithJson(args)) return;
+	if (args.ids === true) {
+		const id = table.id;
+		if (id !== void 0 && rows.length > 0) write(rows.map((row) => id(row)).join(","));
+		return;
+	}
+	if (args.json === true) write(JSON.stringify(json(rows), void 0, 2));
+	else human(rows);
+};
+export { printList as t };