@krapht/ork 0.3.0 → 1.0.0-alpha.0

package/dist/{format-DqpObyMl.mjs → format-CmTlTOjT.mjs}

@@ -1,175 +1,17 @@
-import { C as gitOk, S as git, rt as liveStatus, w as lines, x as removeWorktree } from "./src-Cz1yOUTg.mjs";
-import { i as style, n as cost } from "./output-Q2EdeVUt.mjs";
+import { ht as liveStatus } from "./src-DHvWU4tX.mjs";
+import { i as style, n as cost } from "./output-B1V6ZJSx.mjs";
 import { createInterface } from "node:readline/promises";
-import { existsSync } from "node:fs";
-// ../core/src/worktree/list.ts
-/**
-* @file What `ork worktrees` shows and cleans: every worktree and branch Ork's
-*   runs recorded creating, whatever the project's git rules named them, and
-*   any `ork/*` branch besides, with their state read from git itself.
-*/
-/**
-* The worktrees the project's runs recorded creating, oldest run first; one
-* entry per branch or folder, from the latest run that created it.
-*/
-const createdWorktrees = (store, project) => {
-	const byName = /* @__PURE__ */ new Map();
-	for (const run of store.runs({ project }).toReversed()) for (const { event } of store.events(run.id)) {
-		if (event.type !== "worktree" || event.action !== "created") continue;
-		byName.set(event.branch ?? event.path, {
-			runId: run.id,
-			nodeId: event.id,
-			path: event.path,
-			...event.branch === void 0 ? {} : { branch: event.branch }
-		});
-	}
-	return [...byName.values()];
-};
-const parsePorcelain = (text) => text.split("\n\n").map((block) => lines(block)).map((fields) => {
-	const value = (key) => fields.find((f) => f.startsWith(`${key} `))?.slice(key.length + 1);
-	return {
-		path: value("worktree") ?? "",
-		branch: (value("branch") ?? "").replace(/^refs\/heads\//u, ""),
-		prunable: fields.some((f) => f.startsWith("prunable"))
-	};
-}).filter((entry) => entry.path !== "");
-/** The `ork/<run>/<node>` branches of runs that recorded nothing. */
-const prefixed = (branch) => {
-	const [, runId = "", ...rest] = branch.split("/");
-	return {
-		runId,
-		nodeId: rest.join("/"),
-		path: "",
-		branch
-	};
-};
-/** How many commits a detached worktree holds that no branch, tag or remote has. */
-const onNoBranch = async (entry) => entry === void 0 ? "0" : (await git(entry.path, [
-	"rev-list",
-	"--count",
-	"HEAD",
-	"--not",
-	"--branches",
-	"--tags",
-	"--remotes"
-])).stdout;
-/** One created worktree or branch, with its state read from git. */
-const stateOf = async (root, entries, item) => {
-	const { branch } = item;
-	const entry = branch === void 0 ? entries.find((e) => e.path === item.path) : entries.find((e) => e.branch === branch);
-	const missing = entry !== void 0 && (entry.prunable || !existsSync(entry.path));
-	const status = entry === void 0 || missing ? "" : (await git(entry.path, ["status", "--porcelain"])).stdout;
-	const checkedOut = branch === void 0 && entry !== void 0 && entry.branch !== "" ? entry.branch : void 0;
-	const on = branch ?? checkedOut;
-	const counted = on === void 0 ? await onNoBranch(entry === void 0 || missing ? void 0 : entry) : (await git(root, [
-		"rev-list",
-		"--count",
-		`HEAD..${on}`
-	])).stdout;
-	const ahead = Number(counted);
-	return {
-		...branch === void 0 ? {} : { branch },
-		...checkedOut === void 0 ? {} : { checkedOut },
-		runId: item.runId,
-		nodeId: item.nodeId,
-		path: entry?.path ?? null,
-		missing,
-		dirty: lines(status).length > 0,
-		ahead: Number.isNaN(ahead) ? 0 : ahead,
-		merged: on !== void 0 && ahead === 0,
-		inMainCheckout: entry?.path === root
-	};
-};
-/**
-* Every worktree and branch Ork's runs created in the repository at `root`,
-* with its state: those the runs recorded (`created`, whatever the project's
-* git rules named them), and any `ork/` branch besides. A recorded one that git
-* no longer has is left out.
-*/
-const listOrkWorktrees = async (root, created = []) => {
-	const entries = parsePorcelain(await gitOk(root, [
-		"worktree",
-		"list",
-		"--porcelain"
-	]));
-	const branches = lines(await gitOk(root, [
-		"for-each-ref",
-		"--format=%(refname:short)",
-		"refs/heads/"
-	]));
-	const recordedBranches = new Set(created.flatMap((c) => c.branch ?? []));
-	const items = [...created.filter((c) => c.branch === void 0 ? entries.some((e) => e.path === c.path) : branches.includes(c.branch)), ...branches.filter((b) => b.startsWith("ork/") && !recordedBranches.has(b)).map((b) => prefixed(b))];
-	return Promise.all(items.map((item) => stateOf(root, entries, item)));
-};
-const cleanStep = (item, options) => {
-	if (item.inMainCheckout) return {
-		item,
-		removeWorktree: false,
-		deleteBranch: false,
-		skip: "checked out in the main checkout"
-	};
-	if (item.dirty && !options.force) return {
-		item,
-		removeWorktree: false,
-		deleteBranch: false,
-		skip: "uncommitted changes"
-	};
-	if (item.branch === void 0 && item.checkedOut === void 0 && item.ahead > 0 && !options.force) return {
-		item,
-		removeWorktree: false,
-		deleteBranch: false,
-		skip: "commits on no branch"
-	};
-	const removable = item.path !== null && !item.missing;
-	if (options.branches && item.branch !== void 0 && !item.merged && !options.force) return {
-		item,
-		removeWorktree: removable,
-		deleteBranch: false,
-		skip: "branch not merged"
-	};
-	return {
-		item,
-		removeWorktree: removable,
-		deleteBranch: options.branches && item.branch !== void 0
-	};
-};
-/**
-* What `ork worktrees clean` would do. A worktree with uncommitted changes, an
-* unmerged branch, or a detached worktree holding commits no branch has, is
-* kept unless `force`.
-*/
-const planClean = (items, filter, options) => items.filter((item) => filter.runId === void 0 || item.runId === filter.runId).filter((item) => !filter.merged || item.merged).map((item) => cleanStep(item, options));
-/** Carries out a clean plan, then prunes stale worktree entries. */
-const applyClean = async (root, steps, force) => {
-	const done = [];
-	await gitOk(root, ["worktree", "prune"]);
-	for (const step of steps) {
-		const { item } = step;
-		if (step.removeWorktree && item.path !== null) {
-			await removeWorktree(root, item.path, force);
-			done.push(`removed ${item.path}`);
-		}
-		if (step.deleteBranch && item.branch !== void 0) {
-			await gitOk(root, [
-				"branch",
-				force ? "-D" : "-d",
-				item.branch
-			]);
-			done.push(`deleted ${item.branch}`);
-		}
-	}
-	await gitOk(root, ["worktree", "prune"]);
-	return done;
-};
 // src/human.ts
 /**
 * @file The terminal `HumanChannel`: answers `ask_user` questions, gates and
 *   permission prompts on the terminal, one at a time, and denies or defers
-*   when no one is there. In a run it is the decision queue's local answerer,
-*   racing `ork decide`.
+*   when no one is there. After a choice it offers one optional line for a
+*   note, which Enter skips. In a run it is the decision queue's local
+*   answerer, racing `ork decide`.
 */
 const PREVIEW = 160;
 const NO_ONE_TO_PERMIT = "No one is at the terminal to approve this tool, so it is not allowed in this run.";
+const NOTE_PROMPT = "  Note for the run (optional, Enter to skip): ";
 const NO_ONE_TO_ASK = "no one (nobody is at the terminal; use your best judgment and say so in your report)";
 /** One line that shows what a tool is about to do. */
 const previewInput = (toolName, input) => {
@@ -215,6 +57,12 @@ const createTerminalHuman = (io) => {
 		});
 		return signal === void 0 ? rl.question(text) : rl.question(text, { signal });
 	};
+	/** The optional line after a choice, when the asker takes a note. */
+	const takeNote = async (onNote, signal) => {
+		if (onNote === void 0) return;
+		const note = (await prompt(NOTE_PROMPT, signal)).trim();
+		if (note !== "") onNote(note);
+	};
 	const choose = async (hint, options, recommended, signal) => {
 		const picked = pickOption(await prompt(`  Choose${hint}: `, signal), options, recommended);
 		if (picked !== void 0) return picked;
@@ -227,7 +75,7 @@ const createTerminalHuman = (io) => {
 		return result;
 	};
 	return {
-		permit: ({ nodeId, toolName, input, signal }) => oneAtATime(async () => {
+		permit: ({ nodeId, toolName, input, signal, onNote }) => oneAtATime(async () => {
 			if (signal?.aborted === true) throw new Error("the prompt was withdrawn");
 			say(`${style(["yellow", "bold"], "?")} ${style("bold", nodeId)} wants to run ${previewInput(toolName, input)}`);
 			if (!io.interactive) {
@@ -238,24 +86,28 @@ const createTerminalHuman = (io) => {
 				};
 			}
 			const answer = (await prompt("  Allow? [y/N] ", signal)).trim().toLowerCase();
-			return answer === "y" || answer === "yes" ? { allow: true } : {
+			if (answer === "y" || answer === "yes") return { allow: true };
+			await takeNote(onNote, signal);
+			return {
 				allow: false,
 				message: "The user did not allow this tool."
 			};
 		}),
-		ask: ({ nodeId, question, options, recommended, context, signal }) => oneAtATime(() => {
-			if (signal?.aborted === true) return Promise.reject(/* @__PURE__ */ new Error("the question was withdrawn"));
+		ask: ({ nodeId, question, options, recommended, context, signal, onNote }) => oneAtATime(async () => {
+			if (signal?.aborted === true) throw new Error("the question was withdrawn");
 			say(`${style(["yellow", "bold"], "?")} ${style("bold", nodeId)} asks: ${question}`);
 			if (context !== void 0) say(style("dim", `  ${context}`));
 			for (const [index, option] of options.entries()) say(optionLine(option, index, recommended));
 			if (!io.interactive) {
 				const answer = recommended ?? NO_ONE_TO_ASK;
 				say(style("dim", `  no terminal; answered ${answer}`));
-				return Promise.resolve(answer);
+				return answer;
 			}
 			const fallback = options.findIndex((o) => o.id === recommended);
 			const hint = fallback === -1 ? "" : ` [${String(fallback + 1)}]`;
-			return choose(hint, options, recommended, signal);
+			const picked = await choose(hint, options, recommended, signal);
+			await takeNote(onNote, signal);
+			return picked;
 		}),
 		close: () => {
 			rl?.close();
@@ -291,12 +143,38 @@ const formatBusEvent = (event) => {
 	if (event.type === "owner.answered") return [style("dim", `→ ${event.answer} (owner)`)];
 	return [style("dim", "→ its session ended first; asking you")];
 };
+// src/run/format-result.ts
+const RUN_MARK = {
+	succeeded: style("green", "✓"),
+	failed: style("red", "✗"),
+	budget_exhausted: style("yellow", "!"),
+	quota_exhausted: style("yellow", "!"),
+	timed_out: style("yellow", "!"),
+	interrupted: style("yellow", "!")
+};
+/** `1 failure handled`, `2 failures handled`. */
+const failuresHandled = (count) => `${String(count)} ${count === 1 ? "failure" : "failures"} handled`;
+/**
+* The run summary: status, cost, what ran, what was skipped and which failures
+* an edge handled, branches to look at, why, and mail to nodes that never ran.
+*/
+const formatRunResult = (result) => {
+	const ran = result.nodes.filter((n) => n.runs > 0).length;
+	const skipped = result.skipped ?? result.nodes.length - ran;
+	const handled = result.failuresHandled ?? 0;
+	const lines = ["", `${RUN_MARK[result.status]} run ${result.runId} ${result.status.replace("_", " ")} ${style("dim", `· ${cost(result.costUsd)} · ${String(ran)} ran, ${String(skipped)} skipped${handled === 0 ? "" : `, ${failuresHandled(handled)}`}`)}`];
+	for (const kept of result.worktrees) lines.push(`  ${kept.id}: ${kept.branch ?? "detached"} ${style("dim", `at ${kept.path} (${kept.reason})`)}`);
+	for (const reason of result.reasons) lines.push(`  ${style("red", reason)}`);
+	for (const { node, messages } of result.unread ?? []) lines.push(`  ${style(["yellow", "bold"], "warning")} ${node} never ran, so ${messages === 1 ? "1 message" : `${String(messages)} messages`} to it went unread`);
+	return lines;
+};
 // src/run/format.ts
 /** Who answered a decision, as the log says it. */
 const ANSWERED_BY = {
 	terminal: "terminal",
 	decide: "ork decide",
-	ui: "ork ui"
+	ui: "ork ui",
+	owner: "its owner"
 };
 const STATUS_MARK = {
 	pass: style("green", "✓"),
@@ -330,7 +208,10 @@ const formatOutcome = (nodeId, outcome) => {
 };
 /** The transcript lines for one event; tool names come from `tools`. */
 const formatEvent = (nodeId, event, tools) => {
-	if (event.type === "session.started") return [style("dim", `▸ ${nodeId} (${event.model}, session ${event.sessionId})`)];
+	if (event.type === "session.started") {
+		const fork = event.fork === true ? ", a fork to answer a question" : "";
+		return [style("dim", `▸ ${nodeId} (${event.model}, session ${event.sessionId}${fork})`)];
+	}
 	if (event.type === "assistant.text") return indent(event.text);
 	if (event.type === "tool.called") {
 		tools.set(event.id, event.name);
@@ -361,8 +242,12 @@ const formatRunEvent = (event, width, tools) => {
 	if (event.type === "node.event") {
 		const inner = event.event;
 		if (inner.type === "session.finished") return [];
-		if (inner.type === "session.started") return [`${tag(event.id)} ${style("dim", `${inner.model}, session ${inner.sessionId}`)}`];
-		return formatEvent(event.id, event.event, tools).map((line) => `${tag(event.id)} ${line.replace(/^ {2}/u, "")}`);
+		const fork = inner.fork === true ? style("dim", "fork · ") : "";
+		if (inner.type === "session.started") {
+			const why = inner.fork === true ? ", to answer a question" : "";
+			return [`${tag(event.id)} ${fork}${style("dim", `${inner.model}, session ${inner.sessionId}${why}`)}`];
+		}
+		return formatEvent(event.id, event.event, tools).map((line) => `${tag(event.id)} ${fork}${line.replace(/^ {2}/u, "")}`);
 	}
 	if (event.type === "node.finished") {
 		const mark = event.ok ? style("green", "✓") : style("red", "✗");
@@ -383,11 +268,13 @@ const formatRunEvent = (event, width, tools) => {
 	if (event.type === "decision.opened") {
 		const what = event.kind === "permission" ? "asks to" : "asks:";
 		const question = event.kind === "permission" ? event.question.replace(/^Allow /u, "run ").replace(/\?$/u, "") : event.question;
-		return [`${tag(event.node)} ${style(["yellow", "bold"], "?")} ${what} ${question} ${style("dim", `(decision ${event.decision}; ork decide)`)}`];
+		const where = event.owner === void 0 ? `decision ${event.decision}; ork decide` : `decision ${event.decision}, via ${event.owner}`;
+		return [`${tag(event.node)} ${style(["yellow", "bold"], "?")} ${what} ${question} ${style("dim", `(${where})`)}`];
 	}
 	if (event.type === "decision.answered") {
-		const by = ANSWERED_BY[event.by];
-		return [`${tag(event.node)} ${style("dim", `→ ${event.answer} (${by})`)}`];
+		const by = event.by === "owner" && event.owner !== void 0 ? event.owner : ANSWERED_BY[event.by];
+		const said = event.note === void 0 ? "" : ` · said: ${event.note.replaceAll(/\s+/gu, " ")}`;
+		return [`${tag(event.node)} ${style("dim", `→ ${event.answer} (${by})${said}`)}`];
 	}
 	if (event.type === "decision.withdrawn") return [`${tag(event.node)} ${style("dim", "→ question withdrawn")}`];
 	if (event.type === "run.command") {
@@ -416,23 +303,6 @@ const formatRunEvent = (event, width, tools) => {
 	}
 	return formatBusEvent(event).map((line) => `${tag(event.node)} ${line}`);
 };
-const RUN_MARK = {
-	succeeded: style("green", "✓"),
-	failed: style("red", "✗"),
-	budget_exhausted: style("yellow", "!"),
-	quota_exhausted: style("yellow", "!"),
-	timed_out: style("yellow", "!"),
-	interrupted: style("yellow", "!")
-};
-/** The run summary: status, cost, what ran, branches to look at, and why. */
-const formatRunResult = (result) => {
-	const ran = result.nodes.filter((n) => n.runs > 0).length;
-	const skipped = result.nodes.length - ran;
-	const lines = ["", `${RUN_MARK[result.status]} run ${result.runId} ${result.status.replace("_", " ")} ${style("dim", `· ${cost(result.costUsd)} · ${String(ran)} ran, ${String(skipped)} skipped`)}`];
-	for (const kept of result.worktrees) lines.push(`  ${kept.id}: ${kept.branch ?? "detached"} ${style("dim", `at ${kept.path} (${kept.reason})`)}`);
-	for (const reason of result.reasons) lines.push(`  ${style("red", reason)}`);
-	return lines;
-};
 // src/runs/format.ts
 /**
 * @file How stored runs read on the terminal: the `ork ps` table and the `ork
@@ -466,7 +336,10 @@ const duration = (ms) => {
 	if (s < 3600) return `${String(Math.floor(s / 60))}m${String(s % 60).padStart(2, "0")}s`;
 	return `${String(Math.floor(s / 3600))}h${String(Math.floor(s % 3600 / 60)).padStart(2, "0")}m`;
 };
-/** The `ork ps` table; `withProject` adds each run's project. */
+/**
+* The `ork ps` table; `withProject` adds each run's project. A called run's
+* cost is dimmed and says its caller's, whose cost already counts it.
+*/
 const formatRuns = (runs, withProject, now = Date.now(), statusOf = liveStatus) => {
 	if (runs.length === 0) return ["No runs."];
 	const rows = runs.map((run) => {
@@ -477,7 +350,8 @@ const formatRuns = (runs, withProject, now = Date.now(), statusOf = liveStatus)
 			workflow: run.workflow,
 			status,
 			when: `${ago(run.startedAt, now)} · ${duration(end - Date.parse(run.startedAt))}`,
-			cost: cost(run.costUsd),
+			cost: run.parent === void 0 ? cost(run.costUsd) : `${cost(run.costUsd)} in ${run.parent}`,
+			called: run.parent !== void 0,
 			project: run.project
 		};
 	});
@@ -502,7 +376,7 @@ const formatRuns = (runs, withProject, now = Date.now(), statusOf = liveStatus)
 		r.workflow.padEnd(w.workflow),
 		style(STATUS_STYLE[r.status] ?? "reset", r.status.padEnd(w.status)),
 		style("dim", r.when.padEnd(w.when)),
-		r.cost.padStart(w.cost),
+		r.called ? style("dim", r.cost.padStart(w.cost)) : r.cost.padStart(w.cost),
 		...withProject ? [style("dim", r.project)] : []
 	].join("  "))];
 };
@@ -550,4 +424,4 @@ const formatTree = (roots) => {
 		return `${text.padEnd(label)}  ${style("dim", node.type.padEnd(type))}  ${state}${usage}`;
 	});
 };
-export { formatRunEvent as a, createdWorktrees as c, formatEvent as i, listOrkWorktrees as l, formatRuns as n, createTerminalHuman as o, formatTree as r, applyClean as s, ago as t, planClean as u };
+export { formatRunEvent as a, formatEvent as i, formatRuns as n, createTerminalHuman as o, formatTree as r, ago as t };