@krapht/ork 0.3.0 → 1.0.0-alpha.0

package/dist/clean-NnboOuz6.mjs

@@ -0,0 +1,88 @@
+import { A as gitOk, O as removeWorktree } from "./src-DHvWU4tX.mjs";
+// ../core/src/worktree/clean.ts
+/**
+* @file What `ork worktrees clean` and `ork worktrees remove` do with what
+*   list.ts reads: the plan (what goes, what's kept and why), by one rule for
+*   every caller, and carrying it out. The CLI and the Worktrees panel both
+*   plan here, so neither removes what the other would keep.
+*/
+/** What names an item for `remove`: its branch, or its worktree's path. */
+const keyOf = (item) => item.branch ?? item.path ?? `${item.runId}/${item.nodeId}`;
+/** The reasons no `force` overrides: removing would break something. */
+const MAIN_CHECKOUT = "checked out in the main checkout";
+const RUN_GOING = "its run is still going";
+const kept = (item, skip) => ({
+	item,
+	removeWorktree: false,
+	deleteBranch: false,
+	skip
+});
+/** What clean does with one item. */
+const cleanStep = (item, options) => {
+	if (item.inMainCheckout) return kept(item, MAIN_CHECKOUT);
+	if (item.heldBy !== void 0) return kept(item, `checked out in ${item.heldBy}`);
+	if (options.live?.has(item.runId) === true) return kept(item, RUN_GOING);
+	if (item.dirty && !options.force) return kept(item, "uncommitted changes");
+	if (item.branch === void 0 && item.checkedOut === void 0 && item.ahead > 0 && !options.force) return kept(item, "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
+	};
+};
+/** Whether a step drops a worktree whose folder is gone, by its own path. */
+const stepPrunes = (step) => step.item.missing && step.item.path !== null && step.skip === void 0;
+/** Whether a step does anything. */
+const stepActs = (step) => step.removeWorktree || step.deleteBranch || stepPrunes(step);
+/**
+* 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`; one checked out in the main checkout or in a worktree
+* Ork didn't create, or whose run is still going, is kept even then.
+*/
+const planClean = (items, filter, options) => items.filter((item) => filter.runId === void 0 || item.runId === filter.runId).filter((item) => filter.key === void 0 || keyOf(item) === filter.key).filter((item) => !filter.merged || item.merged).map((item) => cleanStep(item, options));
+/**
+* Carries out one step; what it did goes into `done` as it goes. It touches
+* only its own item: a missing worktree is dropped by its own path (`git
+* worktree remove`), never by `git worktree prune`, which would drop every
+* missing worktree in the repository, the user's own included.
+*/
+const applyStep = async (root, step, force, done) => {
+	const { item } = step;
+	if (stepPrunes(step) && !step.removeWorktree && item.path !== null) {
+		await gitOk(root, [
+			"worktree",
+			"remove",
+			item.path
+		]);
+		done.push(`pruned ${item.path}`);
+	}
+	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}`);
+	}
+};
+/**
+* Carries out a clean plan, step by step. What it did goes into `done` as it
+* goes, so a caller still has it when git fails halfway.
+*/
+const applyClean = async (root, steps, force, done = []) => {
+	for (const step of steps) await applyStep(root, step, force, done);
+	return done;
+};
+export { planClean as a, keyOf as i, applyStep as n, stepActs as o, cleanStep as r, stepPrunes as s, applyClean as t };

package/dist/completion-snnYGjgK.mjs

@@ -0,0 +1,405 @@
+import { Qn as NodeIdSchema, ar as CLAUDE_DRIVERS, bn as placeFiles, ht as liveStatus, xn as placeFor } from "./src-DHvWU4tX.mjs";
+import { a as builtinWorkflowNames, n as pendingDecisions, o as builtinWorkflowText, s as isBuiltinArg } from "./decide-B81wCZQg.mjs";
+import { t as findRun } from "./find-BKW-uGey.mjs";
+import { c as openStore, l as storePath, o as writeErr } from "./output-B1V6ZJSx.mjs";
+import { a as findEntry, c as subcommandsOf, d as SHELL_SCRIPTS, l as COMPLETE_COMMAND, n as groupedEntries, r as argInfoOf, t as groupOf, u as SHELLS } from "./help-groups-BwYoAWsh.mjs";
+import { a as resolveWorkflowArg, n as WORKFLOW_SUFFIX } from "./workflows-CiM7S3l0.mjs";
+import path from "node:path";
+import { parse } from "yaml";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { defineCommand } from "citty";
+/** The store at `~/.ork/state.db`, read-only; none when it can't be read. */
+const readOnlyStore = (file = storePath()) => {
+	if (!existsSync(file)) return void 0;
+	try {
+		return openStore(file, { readOnly: true });
+	} catch {
+		return;
+	}
+};
+/** The project `cwd` is in, from the store's registered projects if any. */
+const placeOf = (cwd, store) => placeFor(cwd, store?.projects() ?? []);
+/** The project's workflows by name, then Ork's own by their `ork:` name. */
+const workflowCandidates = (place) => {
+	const folder = placeFiles(place).workflows;
+	return [...(existsSync(folder) ? readdirSync(folder).filter((name) => name.endsWith(WORKFLOW_SUFFIX)).map((name) => name.slice(0, -WORKFLOW_SUFFIX.length)).toSorted() : []).map((value) => ({
+		value,
+		description: "this project's workflow"
+	})), ...builtinWorkflowNames().map((value) => ({
+		value,
+		description: "one of Ork's workflows"
+	}))];
+};
+/**
+* A workflow argument's text: Ork's own (never written out here), or the file
+* the argument names as every command resolves it; none for a folder.
+*/
+const workflowText = (arg, cwd, place) => {
+	if (isBuiltinArg(arg)) return builtinWorkflowText(arg);
+	const file = path.resolve(cwd, resolveWorkflowArg(arg, cwd, placeFiles(place).workflows));
+	return existsSync(file) && statSync(file).isFile() ? readFileSync(file, "utf8") : void 0;
+};
+/** The node ids of the workflow `arg` names; none when it can't be read. */
+const workflowNodes = (arg, cwd, place) => {
+	const text = workflowText(arg, cwd, place);
+	const parsed = text === void 0 ? void 0 : parse(text);
+	const nodes = parsed !== null && typeof parsed === "object" && "nodes" in parsed ? parsed.nodes : void 0;
+	return (nodes !== null && typeof nodes === "object" ? Object.keys(nodes) : []).filter((key) => NodeIdSchema.safeParse(key).success).map((value) => ({
+		value,
+		description: arg
+	}));
+};
+/**
+* Runs whose id starts with `prefix`, newest first: the project's, else any
+* project's, at most `RUN_LIMIT`.
+*/
+const runCandidates = (store, place, prefix) => {
+	const starts = (id) => id.startsWith(prefix);
+	const own = store.runs({
+		project: place.root,
+		limit: 50
+	}).filter((run) => starts(run.id));
+	const fallback = prefix === "" ? store.runs({ limit: 50 }) : store.lookup(prefix).slice(0, 50);
+	return (own.length > 0 ? own : fallback).map((run) => ({
+		value: run.id,
+		description: `${run.workflow} · ${liveStatus(run)}`
+	}));
+};
+/** The run `arg` names, or the project's newest; its nodes in order. */
+const runNodes = (store, arg, cwd) => {
+	const found = findRun(store, arg, cwd);
+	if (!found.ok) return [];
+	const { id } = found.run;
+	return store.nodes(id).map((value) => ({
+		value,
+		description: `run ${id}`
+	}));
+};
+/** Whose decisions: the run `arg` names, else the project's runs. */
+const decisionFilter = (store, arg, cwd, place) => {
+	if (arg === void 0) return { project: place.root };
+	const found = findRun(store, arg, cwd);
+	return found.ok ? { runId: found.run.id } : void 0;
+};
+/** The open decisions of the run `arg` names, else of the project's runs. */
+const decisionCandidates = (store, arg, cwd, place) => {
+	const filter = decisionFilter(store, arg, cwd, place);
+	return filter === void 0 ? [] : pendingDecisions(store, filter).map((decision) => ({
+		value: decision.id,
+		description: `${decision.kind} of ${decision.runId}/${decision.node}`
+	}));
+};
+// src/completion/values.ts
+const withStore = (context, read) => {
+	const store = context.store();
+	return store === void 0 ? [] : read(store);
+};
+const runs = {
+	group: "runs",
+	values: (context) => withStore(context, (store) => runCandidates(store, placeOf(context.cwd, store), context.current))
+};
+const workflows = {
+	group: "workflows",
+	values: (context) => workflowCandidates(placeOf(context.cwd, context.store()))
+};
+/** A workflow's nodes when the command takes a workflow, else a run's. */
+const nodes = {
+	group: "nodes",
+	values: (context) => {
+		const workflow = context.given["workflow"];
+		if (context.positionals.includes("workflow")) return workflow === void 0 ? [] : workflowNodes(workflow, context.cwd, placeOf(context.cwd, context.store()));
+		return withStore(context, (store) => runNodes(store, context.given["run"], context.cwd));
+	}
+};
+const decisions = {
+	group: "decisions",
+	values: (context) => withStore(context, (store) => decisionCandidates(store, context.given["run"], context.cwd, placeOf(context.cwd, store)))
+};
+const drivers = {
+	group: "drivers",
+	values: () => CLAUDE_DRIVERS.map((driver) => ({
+		value: driver.id,
+		description: driver.label
+	}))
+};
+const files = {
+	group: "files",
+	values: () => [],
+	files: true
+};
+const shells = {
+	group: "shells",
+	values: () => SHELLS.map((value) => ({
+		value,
+		description: ""
+	}))
+};
+/** Providers by argument name, or by command path and name. */
+const VALUE_PROVIDERS = {
+	run: runs,
+	workflow: workflows,
+	files: {
+		...workflows,
+		files: true
+	},
+	node: nodes,
+	"decide id": decisions,
+	"completion shell": shells,
+	driver: drivers,
+	path: files,
+	file: files,
+	output: files
+};
+/** The provider for argument `name` of the command at `path`, if any. */
+const providerFor = (providers, path, name) => providers[[...path, name].join(" ")] ?? providers[name];
+// src/completion/candidates.ts
+/**
+* @file What `ork __complete` offers at a position: subcommands (the root's in
+*   `ork --help`'s groups), a command's public flags, an argument's values from
+*   its provider, or an enum flag's values; filtered by what was typed, and
+*   printed one per line as `value<TAB>description`, with `:group <title>`
+*   before each group and `:files` when file names fit too.
+*/
+const NONE = {
+	sections: [],
+	files: false
+};
+/** The first line of a description, as a menu shows it. */
+const brief = (text) => text.split("\n")[0]?.trim() ?? "";
+const subcommandSections = (position) => {
+	if (position.path.length > 0) return [{
+		title: "commands",
+		candidates: position.subcommands.filter((entry) => !entry.hidden).map((entry) => ({
+			value: entry.name,
+			description: brief(entry.description)
+		}))
+	}];
+	return groupedEntries(position.subcommands).map((group) => ({
+		title: group.title,
+		candidates: group.entries.map((entry) => ({
+			value: entry.name,
+			description: groupOf(entry.name)?.short ?? brief(entry.description)
+		}))
+	}));
+};
+const flagSection = (position) => ({
+	title: "flags",
+	candidates: [...position.flags.flatMap((flag) => [{
+		value: `--${flag.name}`,
+		description: brief(flag.description)
+	}, ...flag.negatable ? [{
+		value: `--no-${flag.name}`,
+		description: `Turn off --${flag.name}`
+	}] : []]), {
+		value: "--help",
+		description: "Show this command's help"
+	}]
+});
+const fromProvider = (provider, context) => provider === void 0 ? NONE : {
+	sections: [{
+		title: provider.group,
+		candidates: provider.values(context)
+	}],
+	files: provider.files === true
+};
+/** Everything that fits at `position`, before filtering. */
+const offerAt = (position, providers, context) => {
+	const { slot, path } = position;
+	if (slot.kind === "flag") return {
+		sections: [flagSection(position)],
+		files: false
+	};
+	if (slot.kind === "value") {
+		const { flag } = slot;
+		if (flag.options.length > 0) {
+			const candidates = flag.options.map((value) => ({
+				value,
+				description: ""
+			}));
+			return {
+				sections: [{
+					title: flag.name,
+					candidates
+				}],
+				files: false
+			};
+		}
+		return fromProvider(providerFor(providers, path, flag.name), context);
+	}
+	const values = slot.positional === void 0 ? NONE : fromProvider(providerFor(providers, path, slot.positional.name), context);
+	return {
+		sections: [...position.index === 0 ? subcommandSections(position) : [], ...values.sections],
+		files: values.files
+	};
+};
+/** What fits at `position`, keeping what starts with the typed word. */
+const offerFor = (position, providers, context) => {
+	const offer = offerAt(position, providers, context);
+	return {
+		sections: offer.sections.map((section) => ({
+			...section,
+			candidates: section.candidates.filter((c) => c.value.startsWith(position.current))
+		})).filter((section) => section.candidates.length > 0),
+		files: offer.files
+	};
+};
+/**
+* A value a shell may insert as it is: no space, control character, quote or
+* shell syntax (`$(…)`, `;`, `*`), and no leading `:`, which would read as one
+* of this output's own lines. Ids, names and flags all fit.
+*/
+const SAFE_VALUE = /^[\w.@+,=/~-][\w.@+,=/~:-]*$/u;
+/** One line per candidate, unsafe values dropped; descriptions on one line. */
+const offerLines = (offer) => [...offer.sections.flatMap((section) => [`:group ${section.title}`, ...section.candidates.filter((c) => SAFE_VALUE.test(c.value)).map((c) => `${c.value}\t${c.description.replaceAll(/\p{Cc}+/gu, " ")}`)]), ...offer.files ? [":files"] : []];
+// src/completion/position.ts
+const flagNamed = (flags, word) => {
+	const name = word.replace(/^-{1,2}/u, "").split("=")[0] ?? "";
+	return flags.find((flag) => flag.name === name || flag.aliases.includes(name) || flag.negatable && name === `no-${flag.name}`);
+};
+/** One word before the cursor, folded into the walk. */
+const step = async (walk, word) => {
+	const { pending, ...settled } = walk;
+	if (pending !== void 0) return {
+		...settled,
+		given: {
+			...walk.given,
+			[pending.name]: word
+		}
+	};
+	if (!walk.rest && word === "--") return {
+		...walk,
+		rest: true
+	};
+	if (!walk.rest && word.startsWith("-")) {
+		const flag = flagNamed(walk.flags, word);
+		if (flag === void 0 || !flag.takesValue) return walk;
+		if (!word.includes("=")) return {
+			...walk,
+			pending: flag
+		};
+		const value = word.slice(word.indexOf("=") + 1);
+		return {
+			...walk,
+			given: {
+				...walk.given,
+				[flag.name]: value
+			}
+		};
+	}
+	const sub = walk.index === 0 ? findEntry(walk.subcommands, word) : void 0;
+	if (sub !== void 0) return {
+		...await argInfoOf(sub.def),
+		path: [...walk.path, sub.name],
+		subcommands: await subcommandsOf(sub.def),
+		given: walk.given,
+		index: 0,
+		rest: false
+	};
+	const positional = walk.positionals[walk.index];
+	const given = positional === void 0 ? walk.given : {
+		...walk.given,
+		[positional.name]: word
+	};
+	return {
+		...walk,
+		given,
+		index: walk.index + 1
+	};
+};
+const slotOf = (walk, current) => {
+	if (walk.pending !== void 0) return {
+		kind: "value",
+		flag: walk.pending
+	};
+	if (!walk.rest && current.startsWith("-")) return { kind: "flag" };
+	const positional = walk.positionals[walk.index];
+	return positional === void 0 ? { kind: "word" } : {
+		kind: "word",
+		positional
+	};
+};
+/**
+* Where `words` (what follows `ork`, the word under the cursor last, maybe
+* empty) leave the cursor, in the command `root`.
+*/
+const positionOf = async (root, words) => {
+	const before = words.slice(0, -1);
+	const current = words.at(-1) ?? "";
+	const start = {
+		...await argInfoOf(root),
+		path: [],
+		subcommands: await subcommandsOf(root),
+		given: {},
+		index: 0,
+		rest: false
+	};
+	const walk = await before.reduce(async (previous, word) => step(await previous, word), Promise.resolve(start));
+	const { pending: _pending, rest: _rest, ...reached } = walk;
+	return {
+		...reached,
+		current,
+		slot: slotOf(walk, current)
+	};
+};
+// src/commands/completion.ts
+/**
+* The candidates for the last of `words` (what follows `ork`; the word under
+* the cursor, maybe empty, last), as `__complete` prints them.
+*/
+const completionLines = async (root, words, cwd, storeFile) => {
+	const position = await positionOf(root, words.length === 0 ? [""] : words);
+	const opened = {};
+	const store = () => {
+		if (!("store" in opened)) opened.store = readOnlyStore(storeFile);
+		return opened.store;
+	};
+	try {
+		return offerLines(offerFor(position, VALUE_PROVIDERS, {
+			cwd,
+			given: position.given,
+			current: position.current,
+			positionals: position.positionals.map((p) => p.name),
+			store
+		}));
+	} finally {
+		opened.store?.close();
+	}
+};
+/** `ork __complete`'s whole job: print the candidates, or nothing. */
+const printCompletions = async (root, args, cwd = process.cwd()) => {
+	try {
+		const words = args[0] === "--" ? args.slice(1) : args;
+		const lines = await completionLines(root, words, cwd);
+		process.stdout.write(lines.map((line) => `${line}\n`).join(""));
+	} catch {}
+};
+/** The hidden `ork __complete` of the command `root`. */
+const completeCommand = (root) => defineCommand({
+	meta: {
+		name: COMPLETE_COMMAND,
+		description: "Print tab-completion candidates (the scripts run it)",
+		hidden: true
+	},
+	run: ({ rawArgs }) => printCompletions(root, rawArgs)
+});
+const completion = defineCommand({
+	meta: {
+		name: "completion",
+		description: `Print a tab-completion script for your shell: ${SHELLS.join(", ")}`
+	},
+	args: { shell: {
+		type: "positional",
+		description: SHELLS.join(", "),
+		required: true
+	} },
+	run: ({ args }) => {
+		const script = SHELL_SCRIPTS[args.shell];
+		if (script === void 0) {
+			writeErr(`No completion for \`${args.shell}\`; there is one for ${SHELLS.join(", ")}.`);
+			process.exitCode = 1;
+			return;
+		}
+		process.stdout.write(script);
+	}
+});
+export { completeCommand, completion, printCompletions };