@krapht/ork 0.2.0 → 0.4.0

package/dist/usage-CT7Z-yjr.mjs

@@ -0,0 +1,419 @@
+import { c as usd, fn as placeFor, lt as liveStatus, mn as runDirOf } from "./src-CGqMati3.mjs";
+import { a as write, c as openStore, i as style, n as cost, o as writeErr, t as confirm } from "./output-CXSJO00X.mjs";
+import { n as listOrkWorktrees, t as createdWorktrees } from "./list-ZvY2OcLq.mjs";
+import { n as usageReport, t as USAGE_DIMENSIONS } from "./report-DK4LGqwF.mjs";
+import "./format-J-a21Yvn.mjs";
+import { n as limitsHere } from "./limits-BDZCmGEu.mjs";
+import { defineCommand } from "citty";
+import { existsSync, rmSync } from "node:fs";
+// ../core/src/store/prune.ts
+/**
+* @file `ork prune` (ADR-046): which runs may lose their transcript, and doing
+*   it. A run goes with the runs it called or was called by, or not at all, and
+*   not while it is live, is linked, or has a worktree or branch left: those
+*   read the run's events. The usage ledger and feedback records stay.
+*/
+const messageOf = (error) => error instanceof Error ? error.message : String(error);
+/**
+* The runs in a project that still have a worktree or branch. With its folder
+* gone, or no longer a repository, there is nothing left to clean up; any other
+* failure says nothing about them, so it rejects.
+*/
+const runsWithWorktrees = (store) => async (root) => {
+	if (!existsSync(root)) return /* @__PURE__ */ new Set();
+	try {
+		const found = await listOrkWorktrees(root, createdWorktrees(store, root));
+		return new Set(found.map((w) => w.runId));
+	} catch (error) {
+		if (/not a git repository/iu.test(messageOf(error))) return /* @__PURE__ */ new Set();
+		throw error;
+	}
+};
+/** The run at the top of a run's chain of calls. */
+const callRootOf = (run, byId) => {
+	let top = run;
+	const seen = /* @__PURE__ */ new Set([run.id]);
+	while (top.parent !== void 0) {
+		const parent = byId.get(top.parent);
+		if (parent === void 0 || seen.has(parent.id)) break;
+		seen.add(parent.id);
+		top = parent;
+	}
+	return top.id;
+};
+/** Sorts the runs before the cutoff into those to remove and those to keep. */
+const planPrune = async (store, filter, worktreesOf = runsWithWorktrees(store)) => {
+	const all = store.runs();
+	const byId = new Map(all.map((run) => [run.id, run]));
+	const inScope = (run) => filter.project === void 0 || run.project === filter.project;
+	const old = (run) => (store.lastEventAt(run.id) ?? run.finishedAt ?? run.startedAt) < filter.before;
+	const trees = /* @__PURE__ */ new Map();
+	for (const run of all) {
+		const root = callRootOf(run, byId);
+		trees.set(root, [...trees.get(root) ?? [], run]);
+	}
+	const projects = [...new Set(all.filter((r) => old(r) && inScope(r)).map((r) => r.project))];
+	const withWorktrees = new Map(await Promise.all(projects.map(async (project) => {
+		try {
+			return [project, await worktreesOf(project)];
+		} catch (error) {
+			return [project, messageOf(error)];
+		}
+	})));
+	/** Why this run itself cannot go, or `null` when it can. */
+	const blocker = (run) => {
+		if (liveStatus(run) === "running") return "it is still running";
+		const worktrees = withWorktrees.get(run.project);
+		if (typeof worktrees === "string") return `cannot tell whether it has a worktree left: ${worktrees}`;
+		if (worktrees?.has(run.id) === true) return "it has a worktree or branch left (ork worktrees clean)";
+		if (store.links({
+			run: run.id,
+			live: true
+		}).length > 0) return "it has a live link";
+		return null;
+	};
+	const plan = {
+		remove: [],
+		keep: []
+	};
+	for (const tree of trees.values()) {
+		const held = tree.map((run) => {
+			if (!inScope(run)) return `run ${run.id} of its call is in another project (--all)`;
+			if (!old(run)) return `run ${run.id} of its call is newer`;
+			const why = blocker(run);
+			return why === null ? null : `run ${run.id} of its call stays: ${why}`;
+		}).find((why) => why !== null);
+		for (const run of tree) {
+			if (!inScope(run) || !old(run)) continue;
+			if (held === void 0) plan.remove.push(run);
+			else plan.keep.push({
+				run,
+				reason: blocker(run) ?? held
+			});
+		}
+	}
+	return plan;
+};
+const SAFE_ID = /^[\w-]+$/u;
+/** Forgets the plan's runs and removes their folders. */
+const applyPrune = (store, plan) => {
+	const outcome = {
+		removed: 0,
+		folders: 0,
+		failed: []
+	};
+	const places = store.projects();
+	for (const run of plan.remove) {
+		if (!store.deleteRun(run.id)) {
+			outcome.failed.push({
+				run: run.id,
+				reason: "it is running again"
+			});
+			continue;
+		}
+		outcome.removed += 1;
+		if (!SAFE_ID.test(run.id)) continue;
+		const place = places.find((p) => p.root === run.project) ?? placeFor(run.project, places);
+		const folder = runDirOf(place, run.id);
+		if (!existsSync(folder)) continue;
+		try {
+			rmSync(folder, {
+				recursive: true,
+				force: true
+			});
+			outcome.folders += 1;
+		} catch (error) {
+			outcome.failed.push({
+				run: run.id,
+				reason: `its folder stays, at ${folder}: ${messageOf(error)}`
+			});
+		}
+	}
+	return outcome;
+};
+// src/runs/usage.ts
+/**
+* @file How usage reads on the terminal (`ork usage`, specs/usage.md), and the
+*   times its `--since`, `--until` and `ork prune --older-than` take.
+*/
+const UNITS = {
+	h: 36e5,
+	d: 864e5,
+	w: 6048e5
+};
+/** `30d`, `12w`, `24h` before `now`, as an ISO time; `null` when it is not one. */
+const agoTime = (text, now) => {
+	const match = /^(\d+)([hdw])$/u.exec(text);
+	if (match === null) return null;
+	const [, amount = "0", unit = "d"] = match;
+	if (Number(amount) === 0) return null;
+	const date = new Date(now - Number(amount) * (UNITS[unit] ?? 0));
+	return Number.isNaN(date.getTime()) ? null : date.toISOString();
+};
+/** A `YYYY-MM-DD` day's start in the machine's time zone, `after` days on. */
+const dayTime = (text, after) => {
+	const match = /^(\d{4})-(\d{2})-(\d{2})$/u.exec(text);
+	if (match === null) return null;
+	const [, year = "", month = "", day = ""] = match;
+	const start = new Date(Number(year), Number(month) - 1, Number(day));
+	if (start.getMonth() !== Number(month) - 1) return null;
+	if (start.getDate() !== Number(day)) return null;
+	start.setDate(start.getDate() + after);
+	return start.toISOString();
+};
+/** The start of the day `days` whole days ago, counting today as one. */
+const wholeDays = (days, now) => {
+	const today = new Date(now);
+	return new Date(today.getFullYear(), today.getMonth(), today.getDate() - (days - 1)).toISOString();
+};
+/**
+* `--since`: an age or the day it starts from. Days and weeks are whole days,
+* today among them, as the Usage panel counts them; hours are exact.
+*/
+const sinceTime = (text, now) => {
+	const ago = agoTime(text, now);
+	if (ago === null) return dayTime(text, 0);
+	if (text.endsWith("h")) return ago;
+	const amount = Number(text.slice(0, -1));
+	return wholeDays(text.endsWith("w") ? amount * 7 : amount, now);
+};
+/** `--until`: the last day it includes. */
+const untilTime = (text) => dayTime(text, 1);
+/** `950`, `12.3k`, `4.5M`. */
+const tokens = (count) => {
+	if (count < 1e3) return String(count);
+	if (count < 1e6) return `${(count / 1e3).toFixed(1)}k`;
+	return `${(count / 1e6).toFixed(1)}M`;
+};
+const percent = (share) => `${String(Math.round(share * 100))}%`;
+const counted = (count, noun) => `${String(count)} ${noun}${count === 1 ? "" : "s"}`;
+const TITLES = {
+	day: "By day",
+	week: "By week",
+	month: "By month",
+	workflow: "By workflow",
+	node: "Costliest nodes",
+	model: "By model",
+	driver: "By driver",
+	project: "By project"
+};
+const table = (groups) => {
+	const rows = groups.map((group) => ({
+		key: group.key,
+		cost: cost(group.costUsd),
+		sessions: String(group.sessions),
+		tokens: `${tokens(group.inputTokens + group.cacheReadTokens + group.cacheWriteTokens)} in / ${tokens(group.outputTokens)} out`,
+		cache: percent(group.cacheHitRate)
+	}));
+	const width = (pick, title) => Math.max(title.length, ...rows.map((row) => pick(row).length));
+	const w = {
+		key: width((r) => r.key, ""),
+		cost: width((r) => r.cost, "COST"),
+		sessions: width((r) => r.sessions, "SESSIONS"),
+		tokens: width((r) => r.tokens, "TOKENS")
+	};
+	const line = (key, c, s, t, h) => `  ${key.padEnd(w.key)}  ${c.padStart(w.cost)}  ${s.padStart(w.sessions)}  ${t.padEnd(w.tokens)}  ${h}`;
+	return [style("dim", line("", "COST", "SESSIONS", "TOKENS", "CACHE")), ...rows.map((r) => line(r.key, r.cost, r.sessions, r.tokens, r.cache))];
+};
+/** What `ork usage` prints without `--by`. */
+const OVERVIEW = [
+	"day",
+	"workflow",
+	"model",
+	"node"
+];
+/** How many rows the overview shows of each; `--by` shows them all. */
+const OVERVIEW_ROWS = 10;
+const shortTime = (iso) => new Date(iso).toLocaleString(void 0, {
+	dateStyle: "medium",
+	timeStyle: "short"
+});
+/** The limits across runs, above a report; nothing with none set. */
+const formatLimits = ({ problems, caps, plan }) => {
+	if (problems.length === 0 && caps.length === 0 && plan.length === 0) return [];
+	return [
+		style("bold", "Limits"),
+		...problems.map((problem) => style("yellow", `  ${problem}`)),
+		...caps.map((cap) => {
+			const line = `  ${cap.project === void 0 ? "all projects" : "this project"}, this ${cap.window}: ${usd(cap.spentUsd)} of ${usd(cap.capUsd)}, resets ${shortTime(cap.resetsAt)}`;
+			return cap.leftUsd <= 0 ? style("yellow", line) : line;
+		}),
+		...plan.map((limit) => style("yellow", `  Claude plan's ${limit.window.replaceAll("_", " ")} limit ${limit.status === "rejected" ? "was reached" : "is close"}${limit.resetsAt === void 0 ? "" : `, resets ${shortTime(limit.resetsAt)}`}`)),
+		""
+	];
+};
+/** The report, as the terminal shows it. */
+const formatUsage = (report, scope, by) => {
+	const { totals } = report;
+	if (totals.sessions === 0) return [`No Claude sessions in ${scope}.`];
+	const lines = [`${style("bold", cost(totals.costUsd))} in ${scope}`, `${counted(totals.runs, "run")} · ${counted(totals.sessions, "session")} · ${counted(totals.turns, "turn")} · ${tokens(totals.inputTokens + totals.cacheReadTokens + totals.cacheWriteTokens)} in / ${tokens(totals.outputTokens)} out · ${percent(totals.cacheHitRate)} from cache`];
+	for (const dimension of by === void 0 ? OVERVIEW : [by]) {
+		const groups = report.groups[dimension];
+		const shown = by === void 0 ? dimension === "day" ? groups.slice(-10) : groups.slice(0, OVERVIEW_ROWS) : groups;
+		lines.push("", style("bold", TITLES[dimension]), ...table(shown));
+		if (shown.length < groups.length) lines.push(style("dim", `  and ${String(groups.length - shown.length)} more (--by ${dimension})`));
+	}
+	const hints = report.hints.length === 0 ? [] : [
+		"",
+		style("bold", "Worth a look"),
+		...report.hints.map((h) => `  ${h.message}`)
+	];
+	return [
+		...lines,
+		...hints,
+		"",
+		style("dim", "Costs are Claude Code's own estimates. On a subscription they are not what you are billed.")
+	];
+};
+// src/commands/usage.ts
+/**
+* @file `ork usage` and `ork prune` (specs/usage.md): what runs spent over
+*   time, from the store's ledger, and forgetting old runs' transcripts while
+*   keeping that ledger.
+*/
+const isDimension = (value) => USAGE_DIMENSIONS.some((dimension) => dimension === value);
+const refuse = (message) => {
+	writeErr(message);
+	process.exitCode = 1;
+};
+const usage = defineCommand({
+	meta: {
+		name: "usage",
+		description: "Show what this project's runs spent over time"
+	},
+	args: {
+		all: {
+			type: "boolean",
+			description: "Every project's runs",
+			default: false
+		},
+		"clear-plan-limits": {
+			type: "boolean",
+			description: "Forget what Claude Code last said of your plan's limits, for one that has lifted",
+			default: false
+		},
+		since: {
+			type: "string",
+			description: "Whole days counting today (30d, 12w), exact hours (24h), a day (2026-11-01), or all",
+			default: "30d"
+		},
+		until: {
+			type: "string",
+			description: "The last day to include"
+		},
+		by: {
+			type: "string",
+			description: USAGE_DIMENSIONS.join(", ")
+		},
+		workflow: {
+			type: "string",
+			description: "Only this workflow"
+		},
+		json: {
+			type: "boolean",
+			description: "Print JSON",
+			default: false
+		}
+	},
+	run: ({ args }) => {
+		const since = args.since === "all" ? void 0 : sinceTime(args.since, Date.now());
+		const until = args.until === void 0 ? void 0 : untilTime(args.until);
+		if (since === null) {
+			refuse(`--since takes an age (30d), a day (2026-11-01) or all, not \`${args.since}\`.`);
+			return;
+		}
+		if (until === null) {
+			refuse(`--until takes a day (2026-11-01), not \`${String(args.until)}\`.`);
+			return;
+		}
+		if (args.by !== void 0 && !isDimension(args.by)) {
+			refuse(`--by takes one of ${USAGE_DIMENSIONS.join(", ")}, not \`${args.by}\`.`);
+			return;
+		}
+		const store = openStore();
+		try {
+			if (args["clear-plan-limits"]) store.clearPlanLimits();
+			const report = usageReport(store.usage({
+				...args.all ? {} : { project: placeFor(process.cwd(), store.projects()).root },
+				...args.workflow === void 0 ? {} : { workflow: args.workflow },
+				...since === void 0 ? {} : { since },
+				...until === void 0 ? {} : { until }
+			}));
+			const limits = limitsHere(store, args.all ? void 0 : placeFor(process.cwd(), store.projects()));
+			if (args.json) {
+				write(JSON.stringify({
+					...report,
+					limits
+				}, void 0, 2));
+				return;
+			}
+			for (const line of formatLimits(limits)) write(line);
+			const place = args.all ? "every project" : "this project";
+			const period = args.since === "all" ? "" : `, since ${args.since}`;
+			for (const line of formatUsage(report, `${place}${period}`, args.by)) write(line);
+		} finally {
+			store.close();
+		}
+	}
+});
+const prune = defineCommand({
+	meta: {
+		name: "prune",
+		description: "Forget old runs' transcripts; what they spent stays"
+	},
+	args: {
+		"older-than": {
+			type: "string",
+			description: "Runs that ended this long ago: 90d, 12w",
+			required: true
+		},
+		all: {
+			type: "boolean",
+			description: "Every project's runs",
+			default: false
+		},
+		"dry-run": {
+			type: "boolean",
+			description: "Show what would go, and change nothing",
+			default: false
+		},
+		yes: {
+			type: "boolean",
+			alias: "y",
+			description: "Do not ask",
+			default: false
+		}
+	},
+	run: async ({ args }) => {
+		const before = agoTime(args["older-than"], Date.now());
+		if (before === null) {
+			refuse(`--older-than takes an age (90d, 12w), not \`${args["older-than"]}\`.`);
+			return;
+		}
+		const store = openStore();
+		try {
+			const filter = {
+				before,
+				...args.all ? {} : { project: placeFor(process.cwd(), store.projects()).root }
+			};
+			const plan = await planPrune(store, filter);
+			for (const { run, reason } of plan.keep) write(style("dim", `keep ${run.id} (${run.workflow}): ${reason}`));
+			for (const run of plan.remove) write(`${args["dry-run"] ? "would remove" : "remove"} ${run.id} (${run.workflow}, ${run.startedAt.slice(0, 10)})`);
+			if (plan.remove.length === 0) {
+				write("Nothing to prune.");
+				return;
+			}
+			if (args["dry-run"]) return;
+			const question = `Forget ${String(plan.remove.length)} run(s) and their logs for good? They can no longer be resumed or read. [y/N] `;
+			if (!args.yes && !await confirm(question)) return;
+			const agreed = new Set(plan.remove.map((run) => run.id));
+			const outcome = applyPrune(store, { remove: (args.yes ? plan : await planPrune(store, filter)).remove.filter((run) => agreed.has(run.id)) });
+			const notShrunk = store.compact();
+			write(`Removed ${String(outcome.removed)} run(s) and ${String(outcome.folders)} folder(s). Their usage stays in \`ork usage\`.${notShrunk === null ? "" : ` The store's file did not shrink: ${notShrunk}. The next prune tries again, and its free space is used first.`}`);
+			for (const { run, reason } of outcome.failed) refuse(`Run ${run}: ${reason}.`);
+		} finally {
+			store.close();
+		}
+	}
+});
+export { prune, usage };