@krapht/ork 1.0.0-alpha.2 → 1.0.0-alpha.20

package/README.md

@@ -1,9 +1,9 @@
 # @krapht/ork
 
-The `ork` command: orchestrate Claude agents on your machine with hierarchical,
-serializable workflows.
+The `ork` command: orchestrate coding agents (Claude Code, OpenCode, Command
+Code) on your machine with hierarchical, serializable workflows.
 
-> **Alpha.** Workflows of Claude agents and tools, run from the terminal or the
+> **Alpha.** Workflows of coding agents and tools, run from the terminal or the
 > browser (`ork ui`). Expect changes until 1.0.0. See the
 > [project README](https://github.com/mimshins/ork#readme), the
 > [guides](https://github.com/mimshins/ork/tree/main/docs#readme) and
@@ -26,10 +26,15 @@ ork worktrees clean     # removes the merged ones; asks first
 ork upgrade             # a newer version? upgrade the way you installed Ork
 ```
 
-A workflow that names no Claude driver runs on the one that's ready: the CLI
-driver uses your own logged-in `claude`; the SDK driver needs
-`ANTHROPIC_API_KEY` or a cloud provider. `--driver cli` or `--driver sdk` picks
-one.
+A workflow that names no agent driver runs on the one that's ready. Today that
+is `claude-code`: your own `claude`, logged in or with `ANTHROPIC_API_KEY` or a
+cloud provider set. Your own `opencode` (`open-code`) and Command Code's `cmd`
+(`command-code`) work too: `--driver <id>`, or a driver per node
+([Drivers](https://github.com/mimshins/ork/blob/main/docs/guides/drivers.md)).
+
+Ork is built with Ork: its own workflows plan, build, review and document its
+features, and each run is measured against a manual session in
+[Benchmarks: Ork building Ork](https://github.com/mimshins/ork/blob/main/benchmarks/README.md).
 
 Ork never stores or asks for credentials: it uses the tools you already have,
 signed in with your own accounts. Once a day it asks the npm registry whether a

package/dist/__build_info__-D6mXC4cD.mjs

@@ -0,0 +1,228 @@
+import { E as parseVersion, T as isNewer, w as compareVersions } from "./src-8cOPOgrT.mjs";
+import path from "node:path";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+// ../core/src/remote/session.ts
+const chattable = (type) => type === "agent.leader" || type === "agent.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.fork === true) continue;
+		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.model !== "") session.model = inner.model;
+		}
+		if (inner.type === "session.finished" && inner.outcome.sessionId !== "") session.sessionId = inner.outcome.sessionId;
+	}
+	return {
+		session,
+		outputs
+	};
+};
+/** The dist-tags every install follows, toward and after 1.0.0. */
+const CHANNEL_TAGS = [
+	"latest",
+	"alpha",
+	"beta",
+	"rc"
+];
+/** The dist-tag of snapshots from `main`, followed only by a canary. */
+const CANARY_TAG = "canary";
+const updateCachePath = (home = homedir()) => path.join(home, ".ork", "update-check.json");
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const text = (record, key) => {
+	const value = record[key];
+	return typeof value === "string" ? value : void 0;
+};
+const notifiedOf = (value) => {
+	if (!isRecord(value)) return void 0;
+	const version = text(value, "version");
+	const at = text(value, "at");
+	return version === void 0 || at === void 0 ? void 0 : {
+		version,
+		at
+	};
+};
+/** The cache, or `null` when there is none or it cannot be read. */
+const readUpdateCache = (file) => {
+	let parsed;
+	try {
+		parsed = JSON.parse(readFileSync(file, "utf8"));
+	} catch {
+		return null;
+	}
+	if (!isRecord(parsed)) return null;
+	const checkedAt = text(parsed, "checkedAt");
+	if (checkedAt === void 0) return null;
+	const latest = text(parsed, "latest");
+	const notified = notifiedOf(parsed["notified"]);
+	return {
+		checkedAt,
+		...latest === void 0 ? {} : { latest },
+		...notified === void 0 ? {} : { notified }
+	};
+};
+/** Writes the cache whole (a temporary file, then a rename). */
+const writeUpdateCache = (file, cache) => {
+	mkdirSync(path.dirname(file), { recursive: true });
+	const temporary = `${file}.${process.pid}.tmp`;
+	writeFileSync(temporary, `${JSON.stringify(cache, null, 2)}\n`);
+	renameSync(temporary, file);
+};
+const age = (iso, now) => {
+	const time = Date.parse(iso);
+	return Number.isNaN(time) ? Infinity : now.getTime() - time;
+};
+/** Whether it is time to ask the registry again. */
+const checkDue = (cache, now) => cache === null || age(cache.checkedAt, now) >= 864e5;
+/** Whether `version` is a canary snapshot: its pre-release starts `canary`. */
+const isCanary = (version) => parseVersion(version)?.pre[0]?.startsWith(CANARY_TAG) === true;
+/**
+* The newest version, by semver precedence, among the dist-tags `current`
+* follows: the channel tags, and `canary` too when `current` is a canary. A tag
+* whose value doesn't parse is skipped; `null` when none does.
+*/
+const newestTagged = (tags, current) => {
+	return (current !== void 0 && isCanary(current) ? [...CHANNEL_TAGS, "canary"] : CHANNEL_TAGS).flatMap((tag) => {
+		const value = tags[tag];
+		const version = typeof value === "string" ? parseVersion(value) : null;
+		return typeof value === "string" && version !== null ? [{
+			value,
+			version
+		}] : [];
+	}).reduce((best, candidate) => best === null || compareVersions(candidate.version, best.version) > 0 ? candidate : best, null)?.value ?? null;
+};
+/**
+* The newest version on the registry that the running version follows ({@link
+* newestTagged}), or `null` on any failure.
+*/
+const fetchLatest = async (name, options = {}) => {
+	const registry = (options.registry ?? "https://registry.npmjs.org").replace(/\/+$/u, "");
+	const get = options.fetch ?? globalThis.fetch;
+	try {
+		const response = await get(`${registry}/-/package/${name}/dist-tags`, {
+			headers: { accept: "application/json" },
+			signal: AbortSignal.timeout(options.timeoutMs ?? 5e3)
+		});
+		if (!response.ok) return null;
+		const tags = await response.json();
+		return isRecord(tags) ? newestTagged(tags, options.current) : null;
+	} catch {
+		return null;
+	}
+};
+/**
+* Asks the registry and records the answer. A failed check is recorded too, so
+* an offline machine is not asked again until the interval passes; the last
+* known version is kept. `options.current` is the running version.
+*/
+const refreshUpdateCache = async (file, name, now, options = {}) => {
+	const before = readUpdateCache(file);
+	const latest = await fetchLatest(name, options) ?? before?.latest;
+	const cache = {
+		...before,
+		checkedAt: now.toISOString(),
+		...latest === void 0 ? {} : { latest }
+	};
+	writeUpdateCache(file, cache);
+	return cache;
+};
+/** The newer version the cache knows of, if any. */
+const newerVersion = (cache, current) => cache?.latest !== void 0 && isNewer(cache.latest, current) ? cache.latest : null;
+/**
+* The version to tell the user about now: newer than theirs, and not already
+* told today. `null` when there is nothing to say.
+*/
+const pendingNotice = (cache, current, now) => {
+	const newer = newerVersion(cache, current);
+	if (newer === null) return null;
+	const told = cache?.notified;
+	return told?.version === newer && age(told.at, now) < 864e5 ? null : newer;
+};
+// ../core/src/update/switches.ts
+/**
+* @file The environment's say over the update check (ADR-038): the variables
+*   that turn it off (`ORK_NO_UPDATE_CHECK`, the common `NO_UPDATE_NOTIFIER`,
+*   and `CI`), and the registry to ask instead of npm's. The CLI adds its own
+*   rules about where a notice may go; the server behind `ork ui` uses only
+*   these.
+*/
+/** Turns the automatic check and its notice off. */
+const NO_UPDATE_ENV = "ORK_NO_UPDATE_CHECK";
+/** A registry to ask instead of npm's, e.g. a company mirror. */
+const UPDATE_REGISTRY_ENV = "ORK_UPDATE_REGISTRY";
+/** The variables that turn the check off, in the order they are looked at. */
+const UPDATE_SWITCHES = [
+	NO_UPDATE_ENV,
+	"NO_UPDATE_NOTIFIER",
+	"CI"
+];
+/** Set to anything but empty, `0` or `false`. */
+const isSwitchedOn = (value) => value !== void 0 && value !== "" && value !== "0" && value.toLowerCase() !== "false";
+/** The variable that turns the check off in `env`, or `null` when none does. */
+const updateSwitchOff = (env) => UPDATE_SWITCHES.find((name) => isSwitchedOn(env[name])) ?? null;
+/** The registry `ORK_UPDATE_REGISTRY` names, if it names one. */
+const registryOf = (env) => {
+	const registry = env[UPDATE_REGISTRY_ENV];
+	return registry === void 0 || registry === "" ? void 0 : registry;
+};
+/** The host of a registry that isn't an http(s) URL, past any `user:pass@`. */
+const hostOf = (registry) => registry.replace(/^[a-z][\w+.-]*:\/\//iu, "").replace(/^[^/?#]*@/u, "").split(/[/?#]/u)[0] ?? "";
+/**
+* The registry as it may be shown (on a page, in a message): an http(s) URL
+* without its user name and password, which a mirror's URL may carry; anything
+* else only as its host.
+*/
+const registryShown = (registry) => {
+	try {
+		const url = new URL(registry);
+		if (url.protocol === "http:" || url.protocol === "https:") {
+			if (url.username === "" && url.password === "") return registry;
+			url.username = "";
+			url.password = "";
+			return url.href;
+		}
+	} catch {}
+	return hostOf(registry);
+};
+// 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 = "1.0.0-alpha.20";
+export { registryShown as a, fetchLatest as c, readUpdateCache as d, refreshUpdateCache as f, nodeSession as h, registryOf as i, newerVersion as l, writeUpdateCache as m, ORK_VERSION as n, updateSwitchOff as o, updateCachePath as p, isSwitchedOn as r, checkDue as s, ORK_NAME as t, pendingNotice as u };

package/dist/apply-Mb0fNpCX.mjs

@@ -0,0 +1,17 @@
+// ../core/src/list-filters/apply.ts
+/**
+* @file Keeps the rows a list's filter matches (RFC-017). The list's own order
+*   and `--limit` stay the caller's: filter, then order, then limit.
+*/
+const fieldMatches = (field, row, wanted) => {
+	if (wanted === void 0 || wanted === "all" || field.get === void 0) return true;
+	const got = field.get(row);
+	if (got === void 0) return false;
+	const values = typeof got === "string" ? [got] : got;
+	if (field.type === "since") return values.some((value) => Date.parse(value) >= Date.parse(wanted));
+	if (field.type === "until") return values.some((value) => Date.parse(value) < Date.parse(wanted));
+	return values.includes(wanted);
+};
+/** The rows of `rows` every field of `filter` matches, in their order. */
+const applyFilters = (table, rows, filter) => rows.filter((row) => table.fields.every((field) => fieldMatches(field, row, filter[field.name])));
+export { applyFilters as t };

package/dist/argument-error-CihH46Le.mjs

@@ -0,0 +1,27 @@
+import { parseArgs } from "citty";
+// src/argument-error.ts
+/**
+* @file The error citty's `runMain` takes for an argument error: the plugins
+*   that refuse a flag (`list/known-flags.ts`) or an extra word
+*   (`extra-arguments.ts`) throw one, so the message is one line and the exit
+*   code is 1, as for a wrong enum value.
+*/
+/**
+* An error citty's `runMain` takes for an argument error (its `CLIError`, which
+* it does not export): a failed parse gives one, and it takes `message`.
+*/
+const argumentError = (message) => {
+	try {
+		parseArgs([], { x: {
+			type: "string",
+			required: true
+		} });
+	} catch (error) {
+		if (error instanceof Error) {
+			error.message = message;
+			return error;
+		}
+	}
+	return new Error(message);
+};
+export { argumentError as t };

package/dist/attach-C1OnxyMh.mjs

@@ -0,0 +1,92 @@
+import "./src-8cOPOgrT.mjs";
+import { t as findRun } from "./find-BTikxc54.mjs";
+import { c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
+import { m as createTerminalHuman, t as attachRun } from "./attach-CEGbRg1D.mjs";
+import { n as attachRefusal } from "./in-a-run-CbnKjO7t.mjs";
+import { t as refuseExtraArguments } from "./extra-arguments-BxQMXARO.mjs";
+import { t as withStore } from "./store-CDpk8Wtz.mjs";
+import { defineCommand } from "citty";
+// src/commands/attach.ts
+/**
+* @file `ork attach`: follow a run and the runs it called on this terminal, and
+*   answer their open decisions here (specs/cli.md). Ctrl-C detaches: the run
+*   keeps going and its decisions stay open (specs/run-control.md).
+*/
+/**
+* Follows `runId` and what it called until it ends or the person detaches, and
+* returns the exit code: 0 when the run succeeded or they detached, else 1.
+*/
+const attachSession = async (store, runId, session) => {
+	const detach = new AbortController();
+	session.signal?.addEventListener("abort", () => {
+		detach.abort();
+	});
+	const interactive = session.terminal?.interactive === true;
+	const human = session.terminal === void 0 || !interactive ? void 0 : createTerminalHuman({
+		...session.terminal,
+		interrupt: () => {
+			detach.abort();
+		}
+	});
+	try {
+		const attached = await attachRun(store, runId, session.out, {
+			signal: detach.signal,
+			hintNoTerminal: human === void 0,
+			...human === void 0 ? {} : { human },
+			...session.home === void 0 ? {} : { home: session.home },
+			...session.intervalMs === void 0 ? {} : { intervalMs: session.intervalMs }
+		});
+		if (detach.signal.aborted) {
+			session.out(style("dim", `detached; run ${runId} keeps going · ork attach ${runId} · ork stop ${runId}`));
+			return 0;
+		}
+		return attached.exitCode;
+	} finally {
+		human?.close();
+	}
+};
+const attach = defineCommand({
+	meta: {
+		name: "attach",
+		description: "Follow a run and the runs it called, and answer their questions here; Ctrl-C detaches"
+	},
+	plugins: [refuseExtraArguments],
+	args: { run: {
+		type: "positional",
+		description: "A run id or a prefix of one",
+		required: true
+	} },
+	run: ({ args }) => withStore(async (store) => {
+		const refusal = process.stdin.isTTY ? attachRefusal() : null;
+		if (refusal !== null) {
+			writeErr(refusal);
+			process.exitCode = 1;
+			return;
+		}
+		const found = findRun(store, args.run, process.cwd());
+		if (!found.ok) {
+			writeErr(found.error);
+			process.exitCode = 1;
+			return;
+		}
+		const abort = new AbortController();
+		const onSigint = () => {
+			abort.abort();
+		};
+		process.once("SIGINT", onSigint);
+		try {
+			process.exitCode = await attachSession(store, found.run.id, {
+				out: write,
+				signal: abort.signal,
+				terminal: {
+					input: process.stdin,
+					output: process.stdout,
+					interactive: process.stdin.isTTY
+				}
+			});
+		} finally {
+			process.off("SIGINT", onSigint);
+		}
+	})
+});
+export { attach };