@krapht/ork 1.0.0-alpha.10 → 1.0.0-alpha.12

package/dist/output-CnRzrbUM.mjs

@@ -0,0 +1,423 @@
+import { stripVTControlCharacters, styleText } from "node:util";
+import { createInterface } from "node:readline/promises";
+// 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/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);
+// 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([...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)}`;
+/**
+* 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 { hang as C, readKeys as E, cut as S, wrap as T, withdrawn as _, style as a, takePlainFlag as b, confirmOrStop as c, apply as d, bold as f, readLine as g, interrupt as h, plain as i, CHIP as l, createRegion as m, cost as n, write as o, paint as p, detachHint as r, writeErr as s, confirm as t, NODE_PALETTE as u, canKey as v, widthOf as w, termOf as x, plainEnv as y };

package/dist/{pause-D7OVB5Ac.mjs → pause-BuS83WAI.mjs}

@@ -1,7 +1,7 @@
-import { D as openStore, X as requestPause, Y as requestContinue } from "./src-Df6KOIDC.mjs";
-import { t as findRun } from "./find-DEjjOlTG.mjs";
-import { a as write, i as style, o as writeErr } from "./output-Bqljtmp_.mjs";
-import { r as continueRefusal } from "./in-a-run-BS9Nc-JW.mjs";
+import { C as openStore, G as requestContinue, K as requestPause } from "./src-CdDTQLdQ.mjs";
+import { t as findRun } from "./find-p05wlbmu.mjs";
+import { a as style, o as write, s as writeErr } from "./output-CnRzrbUM.mjs";
+import { i as continueRefusal } from "./in-a-run-BI-hLIl_.mjs";
 import { defineCommand } from "citty";
 // src/commands/pause.ts
 /**

package/dist/{relay-EceRIebO.mjs → relay-DAsJA8wF.mjs}

@@ -1,5 +1,5 @@
-import { D as openStore, V as addressOf, W as linkNodes, q as unlinkNodes } from "./src-Df6KOIDC.mjs";
-import { a as write, i as style, o as writeErr } from "./output-Bqljtmp_.mjs";
+import { B as linkNodes, C as openStore, L as addressOf, U as unlinkNodes } from "./src-CdDTQLdQ.mjs";
+import { a as style, o as write, s as writeErr } from "./output-CnRzrbUM.mjs";
 import { defineCommand } from "citty";
 // src/commands/relay.ts
 /**

package/dist/{remove-0IQZVWmI.mjs → remove-Dh7D_hVn.mjs}

@@ -1,6 +1,6 @@
-import { M as git, P as lines, bt as liveStatus } from "./src-Df6KOIDC.mjs";
-import { n as listOrkWorktrees, t as createdWorktrees } from "./list-Qxr6rwsY.mjs";
-import { i as keyOf, n as applyStep, r as cleanStep, s as stepPrunes } from "./clean-DVaEH9e7.mjs";
+import { A as lines, O as git, xt as liveStatus } from "./src-CdDTQLdQ.mjs";
+import { n as listOrkWorktrees, t as createdWorktrees } from "./list-zW2xKuGr.mjs";
+import { i as keyOf, n as applyStep, r as cleanStep, s as stepPrunes } from "./clean-D8GI_2K-.mjs";
 // ../core/src/worktree/words.ts
 /**
 * @file The plain words for what `ork worktrees` shows, in one place, so the

package/dist/{report-DK4LGqwF.mjs → report-CEN8VoUb.mjs}

@@ -33,7 +33,9 @@ const TIMES = /* @__PURE__ */ new Set([
 	"week",
 	"month"
 ]);
-const totalsOf = (rows) => {
+/** Dimensions a tool command has no value in. */
+const SESSION_ONLY = /* @__PURE__ */ new Set(["model", "driver"]);
+const totalsOf = (rows, cpu) => {
 	const totals = {
 		costUsd: 0,
 		inputTokens: 0,
@@ -47,7 +49,8 @@ const totalsOf = (rows) => {
 		failedUsd: 0,
 		reworkUsd: 0,
 		chatUsd: 0,
-		cacheHitRate: 0
+		cacheHitRate: 0,
+		cpuMs: cpu.reduce((sum, row) => sum + row.userMs + row.systemMs, 0)
 	};
 	for (const row of rows) {
 		totals.costUsd += row.costUsd;
@@ -65,15 +68,22 @@ const totalsOf = (rows) => {
 	totals.cacheHitRate = read === 0 ? 0 : totals.cacheReadTokens / read;
 	return totals;
 };
-const groupBy = (rows, dimension) => {
+const groupBy = (rows, cpu, dimension) => {
 	const buckets = /* @__PURE__ */ new Map();
-	for (const row of rows) {
+	const bucketOf = (row) => {
 		const key = KEYS[dimension](row);
-		const bucket = buckets.get(key);
-		if (bucket === void 0) buckets.set(key, [row]);
-		else bucket.push(row);
-	}
-	const groups = [...buckets].map(([key, bucket]) => Object.assign(totalsOf(bucket), { key }));
+		const found = buckets.get(key);
+		if (found !== void 0) return found;
+		const fresh = {
+			rows: [],
+			cpu: []
+		};
+		buckets.set(key, fresh);
+		return fresh;
+	};
+	for (const row of rows) bucketOf(row).rows.push(row);
+	if (!SESSION_ONLY.has(dimension)) for (const row of cpu) bucketOf(row).cpu.push(row);
+	const groups = [...buckets].map(([key, bucket]) => Object.assign(totalsOf(bucket.rows, bucket.cpu), { key }));
 	return TIMES.has(dimension) ? groups.toSorted((a, b) => a.key.localeCompare(b.key)) : groups.toSorted((a, b) => b.costUsd - a.costUsd);
 };
 /** Below this, a percentage says nothing worth acting on. */
@@ -107,18 +117,19 @@ const hintsOf = (totals, nodes) => {
 	});
 	return hints;
 };
-/** Everything a report shows, from the ledger's rows. */
-const usageReport = (rows) => {
-	const totals = totalsOf(rows);
+/** Everything a report shows, from the ledger's rows and tool commands' CPU. */
+const usageReport = (rows, cpu = []) => {
+	const totals = totalsOf(rows, cpu);
+	const by = (dimension) => groupBy(rows, cpu, dimension);
 	const groups = {
-		day: groupBy(rows, "day"),
-		week: groupBy(rows, "week"),
-		month: groupBy(rows, "month"),
-		workflow: groupBy(rows, "workflow"),
-		node: groupBy(rows, "node"),
-		model: groupBy(rows, "model"),
-		driver: groupBy(rows, "driver"),
-		project: groupBy(rows, "project")
+		day: by("day"),
+		week: by("week"),
+		month: by("month"),
+		workflow: by("workflow"),
+		node: by("node"),
+		model: by("model"),
+		driver: by("driver"),
+		project: by("project")
 	};
 	return {
 		totals,

package/dist/{send-C0uwfUYi.mjs → send-MFEQZH31.mjs}

@@ -1,6 +1,6 @@
-import { At as scriptContactsOf, D as openStore, an as socketPath, bt as liveStatus, sn as wakeRun } from "./src-Df6KOIDC.mjs";
-import { o as writeErr } from "./output-Bqljtmp_.mjs";
-import { u as inheritedScrubber } from "./src-cmmXKHn1.mjs";
+import { C as openStore, Cn as wakeRun, jt as scriptContactsOf, xn as socketPath, xt as liveStatus } from "./src-CdDTQLdQ.mjs";
+import { s as writeErr } from "./output-CnRzrbUM.mjs";
+import { u as inheritedScrubber } from "./src-BfxkJOYm.mjs";
 import { defineCommand } from "citty";
 // ../core/src/remote/send.ts
 /**