@krapht/ork 0.3.0 → 0.4.0

package/dist/worktrees-DHl80k96.mjs

@@ -0,0 +1,212 @@
+import { T as inspectProject } from "./src-CGqMati3.mjs";
+import { a as write, c as openStore, i as style, o as writeErr, t as confirm } from "./output-CXSJO00X.mjs";
+import { a as planClean, i as keyOf, o as stepActs, t as applyClean } from "./clean-Dcr807be.mjs";
+import { a as readWorktrees, c as planLine, n as lostWork, o as labelOf, r as planRemove, s as mergeStateOf, t as applyRemove, u as stateParts } from "./remove-AwaMMaHf.mjs";
+import { defineCommand } from "citty";
+import path from "node:path";
+// src/project/worktrees.ts
+/**
+* @file What `ork worktrees` prints: each worktree or branch a run left, with
+*   its state read from git, the plan `ork worktrees clean` or `remove` would
+*   carry out, and what a forced remove would lose. The words are core's
+*   (worktree/words.ts), which the Worktrees panel says too; this only colors
+*   them.
+*/
+/** One line of state: its merge state, then what clean would care about. */
+const worktreeState = (item) => {
+	const merge = mergeStateOf(item);
+	const head = merge === "merged" ? [style("green", "merged")] : merge === "detached" ? ["detached"] : [];
+	const parts = stateParts(item).map((part) => part.risk ? style("yellow", part.text) : part.text);
+	return [...head, ...parts].join(" · ");
+};
+/** A name as the list shows it, saying when it's detached. */
+const nameOf = (item) => mergeStateOf(item) === "detached" ? `${labelOf(item)} (detached)` : labelOf(item);
+const formatWorktrees = (items) => {
+	if (items.length === 0) return ["No Ork worktrees or branches."];
+	const width = Math.max(...items.map((i) => nameOf(i).length));
+	return items.flatMap((item) => [`${style("bold", nameOf(item).padEnd(width))}  ${worktreeState(item)}`, ...item.path === null ? [] : [`  ${style("dim", item.path)}`]]);
+};
+const formatPlan = (steps) => steps.map((step) => {
+	const { text, reason } = planLine(step);
+	return `  ${text}${reason === void 0 ? "" : style("dim", ` (${reason})`)}`;
+});
+/** What a forced remove loses, as git prints it, under a heading each. */
+const formatLost = (lost) => [...lost.changes.length === 0 ? [] : ["Uncommitted changes:", ...lost.changes.map((line) => `  ${line}`)], ...lost.commits.length === 0 ? [] : [lost.commitsOn === "no branch" ? "Commits on no branch:" : "Commits not merged:", ...lost.commits.map((line) => `  ${line}`)]];
+// src/commands/worktrees.ts
+/**
+* @file `ork worktrees` (or `ork wt`): lists the worktrees and branches runs
+*   left behind (those the runs recorded creating, whatever the project's git
+*   rules named them, and any `ork/` branch), with their state read from git;
+*   cleans them up safely after showing the plan and asking; and removes one,
+*   the twin of the Worktrees panel's Remove…. The plans are core's, so the
+*   panel keeps and removes exactly what these do.
+*/
+/** The repo this folder is in, and what Ork created there; null outside one. */
+const here = async () => {
+	const root = (await inspectProject(process.cwd()))?.root ?? null;
+	if (root === null) {
+		writeErr("Not in a git repository with a commit.");
+		process.exitCode = 1;
+		return null;
+	}
+	const store = openStore();
+	try {
+		return {
+			root,
+			...await readWorktrees(store, root)
+		};
+	} finally {
+		store.close();
+	}
+};
+/** Asks before acting, unless `--yes`; without a terminal `--yes` is needed. */
+const goAhead = (yes, verb) => {
+	if (yes) return Promise.resolve(true);
+	if (!process.stdin.isTTY) {
+		writeErr(`Pass --yes to ${verb} without a terminal.`);
+		process.exitCode = 1;
+		return Promise.resolve(false);
+	}
+	return confirm("Go ahead? [y/N] ");
+};
+const done = (lines) => {
+	for (const line of lines) write(`${style("green", "✓")} ${line}`);
+};
+const show = async (json) => {
+	const found = await here();
+	if (found === null) return;
+	if (json) write(JSON.stringify(found.items, void 0, 2));
+	else for (const line of formatWorktrees(found.items)) write(line);
+};
+const list = defineCommand({
+	meta: {
+		name: "list",
+		description: "List Ork's worktrees and branches (the default)"
+	},
+	args: { json: {
+		type: "boolean",
+		description: "Print JSON",
+		default: false
+	} },
+	run: ({ args }) => show(args.json)
+});
+const yes = {
+	type: "boolean",
+	description: "Do not ask",
+	default: false
+};
+const clean = defineCommand({
+	meta: {
+		name: "clean",
+		description: "Remove Ork's worktrees (merged ones by default); never one with uncommitted changes unless --force, nor one whose run is still going"
+	},
+	args: {
+		run: {
+			type: "string",
+			description: "Only this run's worktrees"
+		},
+		all: {
+			type: "boolean",
+			description: "Include worktrees whose branch is not merged",
+			default: false
+		},
+		branches: {
+			type: "boolean",
+			description: "Also delete the branches",
+			default: false
+		},
+		force: {
+			type: "boolean",
+			description: "Remove uncommitted changes and unmerged branches too",
+			default: false
+		},
+		yes
+	},
+	run: async ({ args }) => {
+		const found = await here();
+		if (found === null) return;
+		const filter = { merged: !args.all };
+		if (args.run !== void 0) filter.runId = args.run;
+		const steps = planClean(found.items, filter, {
+			branches: args.branches,
+			force: args.force,
+			live: found.live
+		});
+		const acting = steps.filter((s) => stepActs(s));
+		if (acting.length === 0) {
+			for (const line of formatPlan(steps)) write(line);
+			write("Nothing to clean.");
+			return;
+		}
+		write("Plan:");
+		for (const line of formatPlan(steps)) write(line);
+		if (!await goAhead(args.yes, "clean")) return;
+		done(await applyClean(found.root, acting, args.force));
+	}
+});
+const remove = defineCommand({
+	meta: {
+		name: "remove",
+		description: "Remove one of Ork's worktrees, by its branch or its path; --force when that loses work"
+	},
+	args: {
+		target: {
+			type: "positional",
+			description: "The branch, or the worktree's path",
+			required: true
+		},
+		branch: {
+			type: "boolean",
+			description: "Also delete the branch",
+			default: false
+		},
+		force: {
+			type: "boolean",
+			description: "Remove even when that loses uncommitted changes or commits",
+			default: false
+		},
+		yes
+	},
+	run: async ({ args }) => {
+		const found = await here();
+		if (found === null) return;
+		const byPath = path.resolve(args.target);
+		const item = found.items.find((i) => keyOf(i) === args.target || i.path === byPath);
+		const planned = planRemove(found, item === void 0 ? args.target : keyOf(item), args.branch);
+		if (!planned.ok) {
+			writeErr(planned.error);
+			process.exitCode = 1;
+			return;
+		}
+		const { plan } = planned;
+		write("Plan:");
+		for (const line of formatPlan([plan.step])) write(line);
+		if (plan.force) {
+			for (const line of formatLost(await lostWork(found.root, plan))) write(line);
+			if (!args.force) {
+				writeErr("That loses work; pass --force to remove it anyway.");
+				process.exitCode = 1;
+				return;
+			}
+		}
+		if (!await goAhead(args.yes, "remove")) return;
+		done(await applyRemove(found.root, plan));
+	}
+});
+const worktrees = defineCommand({
+	meta: {
+		name: "worktrees",
+		description: "Track and clean up the git worktrees Ork creates for runs"
+	},
+	subCommands: {
+		list,
+		clean,
+		remove
+	},
+	run: async ({ rawArgs }) => {
+		const [first] = rawArgs;
+		if (first === "list" || first === "clean" || first === "remove") return;
+		await show(rawArgs.includes("--json"));
+	}
+});
+export { worktrees };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krapht/ork",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Orchestrate Claude agents on your machine: hierarchical, serializable workflows with a CLI and a localhost UI.",
   "keywords": [
     "claude",
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.309",
-    "@anthropic-ai/sdk": "1.1.0",
+    "@anthropic-ai/sdk": "1.3.0",
     "@modelcontextprotocol/sdk": "1.32.1",
     "citty": "0.2.2",
     "yaml": "2.9.1",
@@ -53,9 +53,9 @@
     "@krapht/ork-schema": "0.0.0",
     "@krapht/ork-server": "0.0.0",
     "@krapht/ork-ui": "0.0.0",
-    "tsdown": "0.23.1"
+    "tsdown": "0.23.4"
   },
   "scripts": {
-    "build": "pnpm --filter @krapht/ork-ui build && node ../../tools/release/build-info.ts && node ../../tools/release/plugin-skills.ts && tsdown && cp ../../LICENSE ../../THIRD_PARTY_NOTICES.md . && cp -R ../ui/dist dist/ui"
+    "build": "pnpm --filter @krapht/ork-ui build && node ../../tools/release/build-info.ts && node ../../tools/release/plugin-skills.ts && node ../../tools/release/builtin-workflows.ts && tsdown && cp ../../LICENSE ../../THIRD_PARTY_NOTICES.md . && cp -R ../ui/dist dist/ui"
   }
 }

package/dist/__build_info__-CXXMLvjt.mjs

@@ -1,104 +0,0 @@
-import { Ft as socketPath, It as wakeRun, rt as liveStatus } from "./src-Cz1yOUTg.mjs";
-// ../core/src/remote/decide.ts
-/**
-* @file The open decisions of live runs, and answering one from another process
-*   (`ork decide`, the local server). An answer goes to the store (the first
-*   one wins), then the run is woken on its socket so it picks the answer up at
-*   once (specs/messaging.md).
-*/
-/** Open decisions whose run is still live, oldest first. */
-const pendingDecisions = (store, filter) => {
-	const live = /* @__PURE__ */ new Map();
-	return store.decisions({
-		...filter,
-		status: "open"
-	}).filter((decision) => {
-		if (!live.has(decision.runId)) {
-			const [run] = store.lookup(decision.runId);
-			live.set(decision.runId, run !== void 0 && liveStatus(run) === "running");
-		}
-		return live.get(decision.runId) === true;
-	});
-};
-/**
-* Answers an open decision with one of its options, and wakes its run. `home`
-* is `~`, where the sockets are (tests pass a folder); `by` says who answered.
-*/
-const answerDecision = async (store, id, choice, home, by = "decide") => {
-	const decision = store.decision(id);
-	if (decision === void 0) return {
-		ok: false,
-		error: `No decision \`${id}\`.`
-	};
-	if (!decision.options.some((o) => o.id === choice)) return {
-		ok: false,
-		error: `\`${choice}\` is not an option of \`${id}\`: \`${decision.options.map((o) => o.id).join("`, `")}\``
-	};
-	if (!store.answerDecision(id, choice, by)) {
-		const now = store.decision(id);
-		return {
-			ok: false,
-			error: now?.status === "answered" ? `${id} was already answered: ${now.answer ?? ""} (${now.answeredBy ?? ""})` : `${id} was withdrawn`
-		};
-	}
-	return {
-		ok: true,
-		woke: await wakeRun(socketPath(decision.runId, home))
-	};
-};
-// ../core/src/remote/session.ts
-const chattable = (type) => type === "claude.leader" || type === "claude.worker";
-/** Reads `node`'s session from a run's events, and every node's last output. */
-const nodeSession = (events, node) => {
-	const session = {
-		known: false,
-		chattable: false,
-		running: false
-	};
-	const outputs = {};
-	for (const { event } of events) {
-		if (event.type === "run.started") {
-			const declared = event.nodes.find((n) => n.id === node);
-			if (declared !== void 0) {
-				session.known = true;
-				session.chattable = chattable(declared.type);
-			}
-		}
-		if (event.type === "node.finished") outputs[event.id] = event.output;
-		if (!("id" in event) || event.id !== node) continue;
-		if (event.type === "node.started") {
-			session.known = true;
-			session.chattable = chattable(event.nodeType);
-			session.running = true;
-		}
-		if (event.type === "node.finished") session.running = false;
-		if (event.type === "worktree" && event.action === "created") session.checkout = {
-			path: event.path,
-			...event.branch === void 0 ? {} : { branch: event.branch },
-			own: true,
-			owner: node
-		};
-		if (event.type !== "node.event") continue;
-		const inner = event.event;
-		if (inner.type === "session.started") {
-			session.sessionId = inner.sessionId;
-			if (inner.cwd !== void 0) session.cwd = inner.cwd;
-			if (inner.driver !== void 0) session.driver = inner.driver;
-		}
-		if (inner.type === "session.finished" && inner.outcome.sessionId !== "") session.sessionId = inner.outcome.sessionId;
-	}
-	return {
-		session,
-		outputs
-	};
-};
-// src/__build_info__.ts
-/**
-* @file The published package's name and version, bound to
-*   `packages/cli/package.json`. Do not edit by hand: `pnpm changesets:version`
-*   and `pnpm build` rewrite it (`tools/release/build-info.ts`), and a test
-*   fails when it is stale.
-*/
-const ORK_NAME = "@krapht/ork";
-const ORK_VERSION = "0.3.0";
-export { pendingDecisions as a, answerDecision as i, ORK_VERSION as n, nodeSession as r, ORK_NAME as t };