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

package/dist/remove-BeGdqroy.mjs

@@ -1,194 +0,0 @@
-import { ht as liveStatus, j as lines, k as git } from "./src-Dujmvv4s.mjs";
-import { n as listOrkWorktrees, t as createdWorktrees } from "./list-BrH8KRSJ.mjs";
-import { i as keyOf, n as applyStep, r as cleanStep, s as stepPrunes } from "./clean-DaHjs__2.mjs";
-// ../core/src/worktree/words.ts
-/**
-* @file The plain words for what `ork worktrees` shows, in one place, so the
-*   CLI and the Worktrees panel say the same thing: an item's name, its merge
-*   state, its state as parts (each marked when it's work that removing would
-*   lose), a plan's line, and why an item can't be removed. The CLI colors
-*   them; the panel lays them out.
-*/
-/** An item's name: its branch, or its run and node when created detached. */
-const labelOf = (item) => item.branch ?? `${item.runId}/${item.nodeId}`;
-/** Merged into the current branch, not, or detached on no branch at all. */
-const mergeStateOf = (item) => {
-	if (item.branch === void 0 && item.checkedOut === void 0) return "detached";
-	return item.merged ? "merged" : "unmerged";
-};
-/** `3 commits`, `1 commit`. */
-const counted = (count, noun) => `${String(count)} ${noun}${count === 1 ? "" : "s"}`;
-/**
-* An item's state, in order: where its worktree is when it isn't plain, the
-* workflow's own branch, uncommitted changes, unmerged or unreachable commits,
-* and the main checkout or another worktree holding the branch. `into` names
-* the branch "not merged" is measured against, when the words should say it.
-*/
-const stateParts = (item, into) => {
-	const parts = [];
-	const part = (text, risk = false) => {
-		parts.push({
-			text,
-			risk
-		});
-	};
-	if (item.path === null) part("no worktree");
-	else if (item.missing) part("missing (prunable)");
-	if (item.checkedOut !== void 0) part(`on the workflow's branch ${item.checkedOut}`);
-	if (item.dirty) part("uncommitted changes", true);
-	const state = mergeStateOf(item);
-	if (state === "unmerged") {
-		const where = into === void 0 ? "" : ` into ${into}`;
-		part(`${counted(item.ahead, "commit")} not merged${where}`);
-	}
-	if (state === "detached") {
-		if (item.ahead > 0) part(`${counted(item.ahead, "commit")} on no branch`, true);
-		else if (item.path !== null && !item.missing) part("nothing committed");
-	}
-	if (item.inMainCheckout) part("checked out in the main checkout");
-	if (item.heldBy !== void 0) part(`checked out in ${item.heldBy}`);
-	return parts;
-};
-/** What a step does, as a plan says it. */
-const planWhat = (step) => {
-	const actions = [
-		...step.removeWorktree ? ["remove worktree"] : [],
-		...stepPrunes(step) && !step.removeWorktree ? ["prune worktree"] : [],
-		...step.deleteBranch ? ["delete branch"] : []
-	];
-	return actions.length > 0 ? actions.join(" + ") : "keep";
-};
-/** `ork/r1/lead: remove worktree`, `r1/check (detached): keep (…)`. */
-const planLine = (step) => {
-	const { item } = step;
-	return {
-		text: `${item.branch === void 0 && item.checkedOut === void 0 ? `${labelOf(item)} (detached)` : labelOf(item)}: ${planWhat(step)}`,
-		...step.skip === void 0 ? {} : { reason: step.skip }
-	};
-};
-/**
-* Why an item can't be removed at all, even forced, if it can't: the main
-* checkout or a worktree Ork didn't create holds it, or its run is still
-* going.
-*/
-const removeRefusal = (item, live) => {
-	if (item.inMainCheckout) return "checked out in the main checkout; switch it to another branch first";
-	if (item.heldBy !== void 0) return `checked out in ${item.heldBy}, a worktree Ork didn't create; switch it to another branch first`;
-	return live ? `run ${item.runId} is still going; stop it first` : void 0;
-};
-// ../core/src/worktree/remove.ts
-/** The ids of the project's runs whose process is still going. */
-const liveRunIds = (store, root) => new Set(store.runs({ project: root }).filter((run) => liveStatus(run) === "running").map((run) => run.id));
-/**
-* Whether `root` is a repository with a commit, and the branch checked out
-* there, which "merged" means merged into (null when its HEAD is detached).
-*/
-const projectHead = async (root) => {
-	if ((await git(root, [
-		"rev-parse",
-		"--verify",
-		"--quiet",
-		"HEAD"
-	])).code !== 0) return { ok: false };
-	const answer = await git(root, [
-		"symbolic-ref",
-		"--short",
-		"-q",
-		"HEAD"
-	]);
-	return {
-		ok: true,
-		branch: answer.code === 0 ? answer.stdout.trim() : null
-	};
-};
-/** What Ork created in the repo at `root`, from its runs' records and git. */
-const readWorktrees = async (store, root) => ({
-	items: await listOrkWorktrees(root, createdWorktrees(store, root)),
-	live: liveRunIds(store, root)
-});
-/**
-* The plan to remove one item, named by `keyOf`. A branch with no worktree is
-* removed by deleting it, so `deleteBranch` is implied there.
-*/
-const planRemove = ({ items, live }, key, deleteBranch) => {
-	const item = items.find((i) => keyOf(i) === key);
-	if (item === void 0) return {
-		ok: false,
-		error: `No Ork worktree or branch ${key}.`,
-		gone: true
-	};
-	const refusal = removeRefusal(item, live.has(item.runId));
-	if (refusal !== void 0) return {
-		ok: false,
-		error: `Can't remove ${labelOf(item)}: ${refusal}.`,
-		gone: false
-	};
-	const branches = item.branch !== void 0 && (deleteBranch || item.path === null);
-	const careful = cleanStep(item, {
-		branches,
-		force: false,
-		live
-	});
-	if (careful.skip === void 0) return {
-		ok: true,
-		plan: {
-			step: careful,
-			force: false
-		}
-	};
-	return {
-		ok: true,
-		plan: {
-			step: cleanStep(item, {
-				branches,
-				force: true,
-				live
-			}),
-			force: true
-		}
-	};
-};
-const out = async (cwd, args) => lines((await git(cwd, args)).stdout);
-/** What carrying out `plan` would lose, read from git. */
-const lostWork = async (root, { step }) => {
-	const { item } = step;
-	const inside = item.path !== null && !item.missing ? item.path : null;
-	const changes = inside !== null && item.dirty && step.removeWorktree ? await out(inside, ["status", "--porcelain"]) : [];
-	if (step.deleteBranch && item.branch !== void 0 && !item.merged) return {
-		changes,
-		commits: await out(root, [
-			"log",
-			"--oneline",
-			`HEAD..${item.branch}`
-		]),
-		commitsOn: "unmerged"
-	};
-	if (item.branch === void 0 && item.checkedOut === void 0 && inside !== null && item.ahead > 0 && step.removeWorktree) return {
-		changes,
-		commits: await out(inside, [
-			"log",
-			"--oneline",
-			"HEAD",
-			"--not",
-			"--branches",
-			"--tags",
-			"--remotes"
-		]),
-		commitsOn: "no branch"
-	};
-	return {
-		changes,
-		commits: [],
-		commitsOn: null
-	};
-};
-/**
-* Carries out a remove plan; what it did goes into `done` as it goes. The
-* caller has checked that a plan needing `force` was asked to force. It touches
-* only its own item, as each of clean's steps does.
-*/
-const applyRemove = async (root, { step, force }, done = []) => {
-	await applyStep(root, step, force, done);
-	return done;
-};
-export { readWorktrees as a, planLine as c, projectHead as i, removeRefusal as l, lostWork as n, labelOf as o, planRemove as r, mergeStateOf as s, applyRemove as t, stateParts as u };

package/dist/report-DK4LGqwF.mjs

@@ -1,129 +0,0 @@
-// ../core/src/usage/report.ts
-const USAGE_DIMENSIONS = [
-	"day",
-	"week",
-	"month",
-	"workflow",
-	"node",
-	"model",
-	"driver",
-	"project"
-];
-const pad = (value) => String(value).padStart(2, "0");
-/** `2026-11-03`, in the machine's own time zone. */
-const dayOf = (date) => `${String(date.getFullYear())}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
-/** The Monday of a time's week. */
-const weekOf = (date) => {
-	const monday = new Date(date);
-	monday.setDate(date.getDate() - (date.getDay() + 6) % 7);
-	return dayOf(monday);
-};
-const KEYS = {
-	day: (row) => dayOf(new Date(row.at)),
-	week: (row) => weekOf(new Date(row.at)),
-	month: (row) => dayOf(new Date(row.at)).slice(0, 7),
-	workflow: (row) => row.workflow,
-	node: (row) => `${row.workflow}/${row.template ?? row.node}`,
-	model: (row) => row.model ?? "unknown",
-	driver: (row) => row.driver ?? "unknown",
-	project: (row) => row.project
-};
-const TIMES = /* @__PURE__ */ new Set([
-	"day",
-	"week",
-	"month"
-]);
-const totalsOf = (rows) => {
-	const totals = {
-		costUsd: 0,
-		inputTokens: 0,
-		outputTokens: 0,
-		cacheReadTokens: 0,
-		cacheWriteTokens: 0,
-		turns: 0,
-		durationMs: 0,
-		sessions: rows.length,
-		runs: new Set(rows.map((row) => row.runId)).size,
-		failedUsd: 0,
-		reworkUsd: 0,
-		chatUsd: 0,
-		cacheHitRate: 0
-	};
-	for (const row of rows) {
-		totals.costUsd += row.costUsd;
-		totals.inputTokens += row.inputTokens;
-		totals.outputTokens += row.outputTokens;
-		totals.cacheReadTokens += row.cacheReadTokens;
-		totals.cacheWriteTokens += row.cacheWriteTokens;
-		totals.turns += row.turns;
-		totals.durationMs += row.durationMs;
-		if (row.failed) totals.failedUsd += row.costUsd;
-		if (row.kind === "chat") totals.chatUsd += row.costUsd;
-		else if (row.round > 1) totals.reworkUsd += row.costUsd;
-	}
-	const read = totals.inputTokens + totals.cacheReadTokens + totals.cacheWriteTokens;
-	totals.cacheHitRate = read === 0 ? 0 : totals.cacheReadTokens / read;
-	return totals;
-};
-const groupBy = (rows, dimension) => {
-	const buckets = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		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 }));
-	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. */
-const MIN_SPEND_USD = .5;
-const REWORK_SHARE = .2;
-const FAILED_SHARE = .1;
-const CONCENTRATED_SHARE = .5;
-const LOW_CACHE_RATE = .5;
-const MIN_CACHE_TOKENS = 1e5;
-const percent = (share) => `${String(Math.round(share * 100))}%`;
-const hintsOf = (totals, nodes) => {
-	const spend = totals.costUsd;
-	if (spend < MIN_SPEND_USD) return [];
-	const hints = [];
-	if (totals.reworkUsd / spend >= REWORK_SHARE) hints.push({
-		code: "rework",
-		message: `${percent(totals.reworkUsd / spend)} of the spend went to loop rounds after the first. Sharper briefs or an earlier check can stop work coming back.`
-	});
-	if (totals.failedUsd / spend >= FAILED_SHARE) hints.push({
-		code: "failed",
-		message: `${percent(totals.failedUsd / spend)} of the spend went to sessions that failed. A cheap check before them, or a lower budget per session, can stop them sooner.`
-	});
-	const top = nodes[0];
-	if (top !== void 0 && nodes.length > 1 && top.costUsd / spend >= CONCENTRATED_SHARE) hints.push({
-		code: "concentrated",
-		message: `${top.key} took ${percent(top.costUsd / spend)} of the spend. It is the first place to try a smaller model, a lower effort or a tighter brief.`
-	});
-	if (totals.inputTokens + totals.cacheReadTokens + totals.cacheWriteTokens >= MIN_CACHE_TOKENS && totals.cacheHitRate < LOW_CACHE_RATE) hints.push({
-		code: "cache",
-		message: `Only ${percent(totals.cacheHitRate)} of input tokens came from the prompt cache. Long runs of fresh sessions cost more than resumed ones.`
-	});
-	return hints;
-};
-/** Everything a report shows, from the ledger's rows. */
-const usageReport = (rows) => {
-	const totals = totalsOf(rows);
-	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")
-	};
-	return {
-		totals,
-		groups,
-		hints: hintsOf(totals, groups.node)
-	};
-};
-export { usageReport as n, USAGE_DIMENSIONS as t };

package/dist/send-C8tunWhv.mjs

@@ -1,163 +0,0 @@
-import { an as wakeRun, ht as liveStatus, kt as scriptContactsOf, rn as socketPath } from "./src-Dujmvv4s.mjs";
-import { c as openStore, o as writeErr } from "./output-BLQWD6MJ.mjs";
-import { u as inheritedScrubber } from "./src-DOcK8Jfp.mjs";
-import { defineCommand } from "citty";
-// ../core/src/remote/send.ts
-/**
-* @file `ork send` (RFC-005): a program in a tool node writes to a session on
-*   its run's bus. The check is on the sender's side, as a refusal must be an
-*   exit code a script can act on; then a row in the store and a wake, as for a
-*   message between linked runs. `ORK_RUN` and `ORK_NODE` say who it is, and
-*   they are attribution, not proof: the check stops mistakes, not a program
-*   running as the same user.
-*/
-/** A first value, as for links; real use will show whether it is the right one. */
-const DEFAULT_SCRIPT_MESSAGES = 100;
-/**
-* Why this sender may not write to this node; `null` when it may. The body is
-* not needed, so a program is told before it pipes a whole message in.
-*/
-const scriptRefusal = (store, send) => {
-	const { run: runId, node, to } = send;
-	if (runId === void 0 || node === void 0) return "`ork send` runs inside a tool node of a run: `ORK_RUN` and `ORK_NODE` are not set.";
-	if (runId.startsWith("node-")) return `Run ${runId} runs one node, which has no message bus; run the whole workflow.`;
-	const run = store.lookup(runId).find((found) => found.id === runId);
-	if (run === void 0) return `There is no run ${runId}.`;
-	const status = liveStatus(run);
-	if (status !== "running") return `Run ${runId} is not running (${status}).`;
-	const started = store.events(runId).map((stored) => stored.event).findLast((event) => event.type === "run.started");
-	if (started === void 0) return `Run ${runId} has not started yet.`;
-	const own = started.nodes.find((found) => found.id === node);
-	if (own === void 0 || !own.type.startsWith("tool.")) return `${node} is not a tool node of run ${runId}.`;
-	const contacts = scriptContactsOf(node, started.nodes, started.channels ?? []);
-	if (contacts.includes(to)) return null;
-	return contacts.length === 0 ? `\`${node}\` has no one to write to: give it an owner, or a channel under \`messages:\`.` : `\`${to}\` is not a contact of \`${node}\`, which can write to \`${contacts.join("`, `")}\` (its owner and its channels).`;
-};
-/** Reading all of it would cost as much as sending it. */
-const TOO_LONG = "The message is over 64 KiB. Write it to a file and send the file's path.";
-/** Checks the message, writes it for the run, and wakes it. */
-const sendFromScript = async (store, send, home) => {
-	const refused = scriptRefusal(store, send);
-	if (refused !== null) return {
-		ok: false,
-		error: refused
-	};
-	if (Buffer.byteLength(send.body) > 65536) return {
-		ok: false,
-		error: TOO_LONG
-	};
-	const run = String(send.run);
-	const node = String(send.node);
-	if (!store.scriptCommand(run, {
-		kind: "script",
-		node: send.to,
-		from: node,
-		body: send.body
-	}, DEFAULT_SCRIPT_MESSAGES)) return {
-		ok: false,
-		error: `\`${node}\` has sent ${String(DEFAULT_SCRIPT_MESSAGES)} messages in this run, which is the most it may.`
-	};
-	await wakeRun(socketPath(run, home));
-	return { ok: true };
-};
-// src/commands/send.ts
-/**
-* @file `ork send` (RFC-005): a program in a tool node writes to a session on
-*   its run's bus. It prints nothing when it works, as what a program prints is
-*   its node's output, and says why on stderr, with exit 1, when it is refused:
-*   before reading a message it could not send, and for anything wrong with the
-*   command itself, which would otherwise go to stdout as usage.
-*/
-const refuse = (message) => {
-	writeErr(message);
-	process.exitCode = 1;
-};
-/** Stdin, up to the limit: past it, the rest is not worth holding. */
-const readBounded = async () => {
-	const chunks = [];
-	let size = 0;
-	for await (const chunk of process.stdin) {
-		const part = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
-		size += part.length;
-		if (size > 65536) return null;
-		chunks.push(part);
-	}
-	return Buffer.concat(chunks);
-};
-/** The message, or why it can't go. */
-const bodyOf = async (given) => {
-	if (given !== void 0) return { body: given };
-	const read = await readBounded();
-	if (read === null) return { refused: TOO_LONG };
-	try {
-		return { body: new TextDecoder("utf-8", { fatal: true }).decode(read) };
-	} catch {
-		return { refused: "The message is not UTF-8 text." };
-	}
-};
-const deliver = async (store, to, given) => {
-	const sender = {
-		run: process.env["ORK_RUN"],
-		node: process.env["ORK_NODE"],
-		to
-	};
-	const refused = scriptRefusal(store, sender);
-	if (refused !== null) {
-		refuse(refused);
-		return;
-	}
-	const message = await bodyOf(given);
-	if ("refused" in message) {
-		refuse(message.refused);
-		return;
-	}
-	if (message.body.replaceAll(/[\p{Cc}\s]/gu, "") === "") {
-		refuse("The message is empty.");
-		return;
-	}
-	const sent = await sendFromScript(store, {
-		...sender,
-		body: inheritedScrubber(process.env)(message.body)
-	});
-	if (!sent.ok) refuse(sent.error);
-};
-const send = defineCommand({
-	meta: {
-		name: "send",
-		description: "From a tool node's program: write to a session in its run"
-	},
-	args: {
-		to: {
-			type: "positional",
-			description: "The node to write to: the owner, or a channel",
-			required: false
-		},
-		message: {
-			type: "string",
-			alias: "m",
-			description: "The message"
-		},
-		stdin: {
-			type: "boolean",
-			description: "Read the message from stdin",
-			default: false
-		}
-	},
-	run: async ({ args }) => {
-		if (args.to === void 0 || args._.length !== 1) {
-			refuse("Give one node to write to: ork send <to> -m <body>.");
-			return;
-		}
-		if (args.message === void 0 === !args.stdin) {
-			refuse("Give the message with -m or --stdin, one of them.");
-			return;
-		}
-		const store = openStore();
-		try {
-			await deliver(store, args.to, args.message);
-		} finally {
-			store.close();
-		}
-	}
-});
-export { send };