@krapht/ork 1.0.0-alpha.12 → 1.0.0-alpha.13

package/dist/{mcp-CM3b65AZ.mjs → mcp-bcctR-wc.mjs}

@@ -1,8 +1,8 @@
-import { u as isNewer } from "./src-CdDTQLdQ.mjs";
-import { n as ORK_VERSION } from "./__build_info__-BJbE3Zvp.mjs";
-import { p as runMarkerIn } from "./src-BfxkJOYm.mjs";
-import { n as explainNode } from "./context-BAwgVSX5.mjs";
-import { a as openMcp, c as refused, o as tool, s as answer } from "./src-S9yK2OHU.mjs";
+import { d as isNewer } from "./src-BeR6f70A.mjs";
+import { n as ORK_VERSION } from "./__build_info__-Da73_nBs.mjs";
+import { p as runMarkerIn } from "./src-D93tHZ5B.mjs";
+import { n as explainNode } from "./context-DHudLA5e.mjs";
+import { a as openMcp, c as refused, o as tool, s as answer } from "./src-CGJGL1sZ.mjs";
 import { z } from "zod";
 import { defineCommand } from "citty";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -43,7 +43,7 @@ const orkMcpServer = (options = {}) => {
 		...options.script === void 0 ? {} : { script: options.script }
 	});
 	const all = [...opened.tools, explainTool(opened, options.home)];
-	const tools = options.expects !== void 0 && isNewer(options.expects, "1.0.0-alpha.12") ? tooOld(all, options.expects) : all;
+	const tools = options.expects !== void 0 && isNewer(options.expects, "1.0.0-alpha.13") ? tooOld(all, options.expects) : all;
 	const server = new McpServer({
 		name: "ork",
 		version: ORK_VERSION

package/dist/once-DPQu5Q3H.mjs

@@ -0,0 +1,76 @@
+import "./src-BeR6f70A.mjs";
+import { t as runOnce } from "./run-CQIfq918.mjs";
+import { a as style, o as write, s as writeErr } from "./output-CnRzrbUM.mjs";
+import { t as ago } from "./format-C60TFpRe.mjs";
+import { spawn } from "node:child_process";
+import { defineCommand, parseArgs } from "citty";
+// src/commands/once.ts
+/**
+* @file `ork once -- <command>`: runs a command unless the same check already
+*   passed on identical files, and records a pass (specs/check-once.md). The
+*   command's own output and exit code are `ork once`'s; a hit prints one line
+*   and exits 0. Everything after `--` is the command, so its flags are never
+*   Ork's.
+*/
+const args = {
+	as: {
+		type: "string",
+		description: "The check's name (default: the command's text)"
+	},
+	covers: {
+		type: "string",
+		description: "Also record the pass for this name (repeat for more)"
+	},
+	"with-head": {
+		type: "boolean",
+		description: "Key the check by HEAD too (for checks relative to it)"
+	},
+	force: {
+		type: "boolean",
+		description: "Run even after a pass"
+	}
+};
+/** The command's exit code: a signal or a program that can't start is 1. */
+const exitCodeOf = (command) => new Promise((resolve) => {
+	const [program = "", ...rest] = command;
+	const child = spawn(program, rest, { stdio: "inherit" });
+	child.on("error", (error) => {
+		writeErr(`Cannot run ${program}: ${error.message}`);
+		resolve(1);
+	});
+	child.on("close", (code) => {
+		resolve(code ?? 1);
+	});
+});
+const listOf = (value) => [value].flat().filter((item) => typeof item === "string" && item !== "");
+const once = defineCommand({
+	meta: {
+		name: "once",
+		description: "Run a command unless the same check already passed on these files: ork once [flags] -- <command…>"
+	},
+	args,
+	run: async ({ rawArgs }) => {
+		const split = rawArgs.indexOf("--");
+		const command = split === -1 ? [] : rawArgs.slice(split + 1);
+		if (command.length === 0) {
+			writeErr("Say what to run after --: ork once [--as <name>] [--covers <name>] [--with-head] [--force] -- <command…>");
+			process.exitCode = 1;
+			return;
+		}
+		const given = parseArgs(rawArgs.slice(0, split), args);
+		const run = process.env["ORK_RUN"];
+		const node = process.env["ORK_NODE"];
+		const result = await runOnce({
+			cwd: process.cwd(),
+			name: given["as"] ?? command.join(" "),
+			covers: listOf(given["covers"]),
+			withHead: given["with-head"] === true,
+			force: given["force"] === true,
+			...run === void 0 || node === void 0 ? {} : { who: `${run}/${node}` },
+			run: () => exitCodeOf(command)
+		});
+		if (result.skipped) write(`${style("green", "✓")} check already passed on these files · ${ago(result.pass.at)} · ${result.pass.who}`);
+		process.exitCode = result.code;
+	}
+});
+export { once };

package/dist/{pause-BuS83WAI.mjs → pause-BPvlDIvz.mjs}

@@ -1,7 +1,7 @@
-import { C as openStore, G as requestContinue, K as requestPause } from "./src-CdDTQLdQ.mjs";
-import { t as findRun } from "./find-p05wlbmu.mjs";
+import { U as requestContinue, W as requestPause, w as openStore } from "./src-BeR6f70A.mjs";
+import { t as findRun } from "./find-CjsNYAAf.mjs";
 import { a as style, o as write, s as writeErr } from "./output-CnRzrbUM.mjs";
-import { i as continueRefusal } from "./in-a-run-BI-hLIl_.mjs";
+import { i as continueRefusal } from "./in-a-run-BYjTXaST.mjs";
 import { defineCommand } from "citty";
 // src/commands/pause.ts
 /**

package/dist/{relay-DAsJA8wF.mjs → relay-C8W0t_zc.mjs}

@@ -1,4 +1,4 @@
-import { B as linkNodes, C as openStore, L as addressOf, U as unlinkNodes } from "./src-CdDTQLdQ.mjs";
+import { F as addressOf, R as linkNodes, V as unlinkNodes, w as openStore } from "./src-BeR6f70A.mjs";
 import { a as style, o as write, s as writeErr } from "./output-CnRzrbUM.mjs";
 import { defineCommand } from "citty";
 // src/commands/relay.ts

package/dist/{remove-Dh7D_hVn.mjs → remove-BkFWGVYo.mjs}

@@ -1,6 +1,6 @@
-import { A as lines, O as git, xt as liveStatus } from "./src-CdDTQLdQ.mjs";
-import { n as listOrkWorktrees, t as createdWorktrees } from "./list-zW2xKuGr.mjs";
-import { i as keyOf, n as applyStep, r as cleanStep, s as stepPrunes } from "./clean-D8GI_2K-.mjs";
+import { Bt as lines, Rt as git, _t as liveStatus } from "./src-BeR6f70A.mjs";
+import { n as listOrkWorktrees, t as createdWorktrees } from "./list-BUb5Uc3H.mjs";
+import { i as keyOf, n as applyStep, r as cleanStep, s as stepPrunes } from "./clean-Bh4KZgzc.mjs";
 // ../core/src/worktree/words.ts
 /**
 * @file The plain words for what `ork worktrees` shows, in one place, so the

package/dist/run-CQIfq918.mjs

@@ -0,0 +1,192 @@
+import { Rt as git, zt as gitOk } from "./src-BeR6f70A.mjs";
+import path from "node:path";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { tmpdir } from "node:os";
+// ../core/src/once/key.ts
+/**
+* @file The key of a check run once (`ork once`, `verify: { once: true }`): the
+*   working tree's files as a git tree (tracked and untracked, not ignored),
+*   written through a temporary index so the real one is untouched, with `HEAD`
+*   and the repository's common git folder, where passes are kept for every
+*   worktree. The key is the files, not the commit: a commit or a no-op rebase
+*   keeps it.
+*/
+/**
+* The key of the files in the worktree at `cwd`. Rejects outside a git
+* repository. Starts from a copy of the real index, so git hashes only the
+* files whose stat changed.
+*/
+const treeKeyOf = async (cwd) => {
+	const [commonDir = "", index = ""] = (await gitOk(cwd, [
+		"rev-parse",
+		"--git-common-dir",
+		"--git-path",
+		"index"
+	])).split("\n").map((line) => path.resolve(cwd, line.trim()));
+	const scratch = mkdtempSync(path.join(tmpdir(), "ork-once-"));
+	const env = { GIT_INDEX_FILE: path.join(scratch, "index") };
+	try {
+		if (existsSync(index)) copyFileSync(index, env.GIT_INDEX_FILE);
+		await gitOk(cwd, ["add", "-A"], env);
+		const tree = (await gitOk(cwd, ["write-tree"], env)).trim();
+		const head = await git(cwd, [
+			"rev-parse",
+			"--verify",
+			"-q",
+			"HEAD"
+		]);
+		return {
+			tree,
+			head: head.code === 0 ? head.stdout.trim() : null,
+			commonDir
+		};
+	} finally {
+		rmSync(scratch, {
+			recursive: true,
+			force: true
+		});
+	}
+};
+// ../core/src/once/store.ts
+/**
+* @file The passes of checks run once, kept in `<git-common-dir>/ork-once/`,
+*   outside every worktree and shared by all of them. A pass is one JSON file
+*   per check name, files and Node version; it holds the tree, `HEAD`, the time
+*   and who ran it, nothing else. Only a passing run writes one (Ork's process
+*   or the check's own, never an agent's edit). Pruned past 7 days or 500
+*   entries.
+*/
+const ONCE_MAX_AGE_MS = 6048e5;
+/** The folder of passes for a repository's common git folder. */
+const onceDirOf = (commonDir) => path.join(commonDir, "ork-once");
+const fileOf = (dir, name, tree, node) => path.join(dir, `${createHash("sha256").update(JSON.stringify([
+	name,
+	tree,
+	node
+])).digest("hex")}.json`);
+const read = (file) => {
+	try {
+		const value = JSON.parse(readFileSync(file, "utf8"));
+		if (typeof value !== "object" || value === null || !("name" in value && "tree" in value && "head" in value && "node" in value && "at" in value && "who" in value)) return null;
+		const { name, tree, head, node, at, who } = value;
+		return typeof name === "string" && typeof tree === "string" && (typeof head === "string" || head === null) && typeof node === "string" && typeof at === "string" && typeof who === "string" ? {
+			name,
+			tree,
+			head,
+			node,
+			at,
+			who
+		} : null;
+	} catch {
+		return null;
+	}
+};
+/** The pass of `name` on these files, or `null`. */
+const findPass = ({ key, name, withHead = false, node = process.version }) => {
+	const pass = read(fileOf(onceDirOf(key.commonDir), name, key.tree, node));
+	if (pass === null || pass.tree !== key.tree || pass.node !== node) return null;
+	return withHead && pass.head !== key.head ? null : pass;
+};
+/** Records a pass under `name` and each covered name, then prunes. */
+const recordPass = ({ key, name, covers = [], who, node = process.version, at = /* @__PURE__ */ new Date() }) => {
+	const dir = onceDirOf(key.commonDir);
+	mkdirSync(dir, { recursive: true });
+	const pass = {
+		name,
+		tree: key.tree,
+		head: key.head,
+		node,
+		at: at.toISOString(),
+		who
+	};
+	for (const each of [name, ...covers]) {
+		const temp = path.join(dir, `.${randomUUID()}.tmp`);
+		writeFileSync(temp, `${JSON.stringify({
+			...pass,
+			name: each
+		})}\n`);
+		renameSync(temp, fileOf(dir, each, pass.tree, node));
+	}
+	prunePasses(key.commonDir, { now: at });
+	return pass;
+};
+/**
+* Removes passes older than `maxAgeMs` or past the newest `maxEntries`, and
+* files that don't read as a pass. Returns how many it removed.
+*/
+const prunePasses = (commonDir, { now = /* @__PURE__ */ new Date(), maxAgeMs = ONCE_MAX_AGE_MS, maxEntries = 500 } = {}) => {
+	const dir = onceDirOf(commonDir);
+	let names;
+	try {
+		names = readdirSync(dir).filter((name) => name.endsWith(".json"));
+	} catch {
+		return 0;
+	}
+	const kept = [];
+	const stale = [];
+	for (const name of names) {
+		const file = path.join(dir, name);
+		const at = Date.parse(read(file)?.at ?? "");
+		if (Number.isNaN(at) || now.getTime() - at > maxAgeMs) stale.push(file);
+		else kept.push({
+			file,
+			at
+		});
+	}
+	kept.sort((a, b) => b.at - a.at);
+	stale.push(...kept.slice(maxEntries).map((entry) => entry.file));
+	for (const file of stale) rmSync(file, { force: true });
+	return stale.length;
+};
+// ../core/src/once/run.ts
+/**
+* @file Runs a check once per set of files, for `ork once` and for
+*   `verify:`/tool commands with `once: true`: skip it when the same check
+*   already passed on identical files, else run it and record a pass when it
+*   exits 0 and the files didn't change while it ran. `force` and
+*   `ORK_ONCE=off` run it anyway; outside a git repository it always runs.
+*/
+/** `null` outside a git repository: nothing to key the files by. */
+const keyOf = (cwd) => treeKeyOf(cwd).catch(() => null);
+/** Runs `run` unless the check already passed on these files. */
+const runOnce = async ({ cwd, name, covers = [], withHead = false, force = false, who = "you", run, env = process.env, node = process.version }) => {
+	if (env["ORK_ONCE"] === "off") return {
+		skipped: false,
+		code: await run()
+	};
+	const before = await keyOf(cwd);
+	const earlier = before === null || force ? null : findPass({
+		key: before,
+		name,
+		withHead,
+		node
+	});
+	if (earlier !== null) return {
+		skipped: true,
+		pass: earlier,
+		code: 0
+	};
+	const code = await run();
+	if (code !== 0 || before === null) return {
+		skipped: false,
+		code
+	};
+	const after = await keyOf(cwd);
+	if (after?.tree !== before.tree || after.head !== before.head) return {
+		skipped: false,
+		code
+	};
+	return {
+		skipped: false,
+		pass: recordPass({
+			key: before,
+			name,
+			covers,
+			who,
+			node
+		}),
+		code
+	};
+};
+export { runOnce as t };

package/dist/{send-MFEQZH31.mjs → send-CaZlGG5a.mjs}

@@ -1,6 +1,6 @@
-import { C as openStore, Cn as wakeRun, jt as scriptContactsOf, xn as socketPath, xt as liveStatus } from "./src-CdDTQLdQ.mjs";
+import { Cn as socketPath, Dt as scriptContactsOf, Tn as wakeRun, _t as liveStatus, w as openStore } from "./src-BeR6f70A.mjs";
 import { s as writeErr } from "./output-CnRzrbUM.mjs";
-import { u as inheritedScrubber } from "./src-BfxkJOYm.mjs";
+import { u as inheritedScrubber } from "./src-D93tHZ5B.mjs";
 import { defineCommand } from "citty";
 // ../core/src/remote/send.ts
 /**