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

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-CLs_fyg7.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-D6_xjm-x.mjs";
-import { o as writeErr } from "./output-CM95njYt.mjs";
-import { u as inheritedScrubber } from "./src-9iGkjnsy.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-D93tHZ5B.mjs";
 import { defineCommand } from "citty";
 // ../core/src/remote/send.ts
 /**