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

package/dist/format-CiPhQqbX.mjs

@@ -0,0 +1,260 @@
+import { Fn as lockWaitsOf, Ln as runStatus, Nt as lockWaitLine, Pn as liveStatus, Rn as slotWaitingOf, Vn as yoloOf, Wn as isItem, jr as maskSecrets, zn as slotWaitsOf, zt as slotWaitLine } from "./src-BuF9Lbow.mjs";
+import { n as cost, o as shortCount, r as costOf, s as style, v as termOf, x as widthOf, y as cut } from "./output-DXZbnFt_.mjs";
+import { a as statusChip, r as chip } from "./chips-CP_pgKlj.mjs";
+import { n as nodeVerdict } from "./verdict-B592j1W3.mjs";
+// src/term/table.ts
+/**
+* @file Aligned columns for the listing commands: each column as wide as its
+*   widest cell, a two-space gap, the last column left unpadded. Rich, a cell
+*   may be a chip and a table wider than the screen cuts its flexible columns
+*   with `…`; plain, nothing is cut or styled, as the listings always printed.
+*/
+/** A dimmed header cell. */
+const header = (text) => ({
+	text,
+	look: (s) => style("dim", s)
+});
+const GAP = "  ";
+/** A flexible column is never cut under this many columns. */
+const MIN_FLEX = 8;
+/** The text a cell shows, and its columns. */
+const shown = (term, cell) => term.rich && cell.chip !== void 0 ? cell.chip.label : cell.text;
+const widthOfCell = (term, cell) => widthOf(shown(term, cell)) + (term.rich && cell.chip !== void 0 ? 2 : 0);
+/** The lines of a table, one per row (a header is a row the caller passes). */
+const table = (term, columns, rows, indent = "") => {
+	const widths = columns.map((_, c) => Math.max(0, ...rows.map((row) => widthOfCell(term, row[c] ?? { text: "" }))));
+	if (term.rich) {
+		const gaps = 2 * (columns.length - 1);
+		let over = indent.length + widths.reduce((a, b) => a + b, 0) + gaps - term.width;
+		columns.forEach((column, c) => {
+			const width = widths[c] ?? 0;
+			if (over <= 0 || column.flex !== true || width <= MIN_FLEX) return;
+			const next = Math.max(MIN_FLEX, width - over);
+			over -= width - next;
+			widths[c] = next;
+		});
+	}
+	const last = columns.length - 1;
+	return rows.map((row) => indent + columns.map((column, c) => {
+		const cell = row[c] ?? { text: "" };
+		const width = widths[c] ?? 0;
+		const look = cell.look ?? ((s) => s);
+		if (term.rich && cell.chip !== void 0) {
+			const used = widthOfCell(term, cell);
+			const pad = " ".repeat(Math.max(0, width - used));
+			return column.align === "right" ? pad + chip(term, cell.chip.label, cell.chip.role) : chip(term, cell.chip.label, cell.chip.role) + (c === last ? "" : pad);
+		}
+		const text = cut(shown(term, cell), width);
+		const pad = " ".repeat(Math.max(0, width - widthOf(text)));
+		if (column.align === "right") return look(pad + text);
+		return c === last ? look(text) : look(text + pad);
+	}).join(GAP));
+};
+// src/runs/format.ts
+/**
+* @file How stored runs read on the terminal: the `ork ps` table and the `ork
+*   tree` ownership tree with each node's state, tokens and cost, and what is
+*   paused (ADR-041).
+*/
+const STATUS_STYLE = {
+	running: "cyan",
+	paused: "yellow",
+	succeeded: "green",
+	failed: "red",
+	crashed: "red",
+	budget_exhausted: "yellow",
+	quota_exhausted: "yellow",
+	timed_out: "yellow",
+	interrupted: "yellow"
+};
+/** `just now`, `5m ago`, `3h ago`, `2d ago`, then the date. */
+const ago = (iso, now = Date.now()) => {
+	const minutes = Math.floor((now - Date.parse(iso)) / 6e4);
+	if (minutes < 1) return "just now";
+	if (minutes < 60) return `${String(minutes)}m ago`;
+	if (minutes < 1440) return `${String(Math.floor(minutes / 60))}h ago`;
+	if (minutes < 10080) return `${String(Math.floor(minutes / 1440))}d ago`;
+	return iso.slice(0, 10);
+};
+/** `42s`, `3m12s`, `1h05m`. */
+const duration = (ms) => {
+	const s = Math.max(0, Math.round(ms / 1e3));
+	if (s < 60) return `${String(s)}s`;
+	if (s < 3600) return `${String(Math.floor(s / 60))}m${String(s % 60).padStart(2, "0")}s`;
+	return `${String(Math.floor(s / 3600))}h${String(Math.floor(s % 3600 / 60)).padStart(2, "0")}m`;
+};
+const dim = (s) => style("dim", s);
+/**
+* A run's status as `ork ps` reads it: for a running run, `waiting for <lock>,
+* held by <run>/<node>` with a node waiting for a lock, or `waiting for slot`
+* with a command waiting for a machine-wide slot; `events` are a running
+* run's.
+*/
+const listedStatus = (run, events) => {
+	const status = runStatus(run, events);
+	if (status !== "running") return status;
+	const [lock] = lockWaitsOf(events);
+	if (lock !== void 0) return lockWaitLine(lock.lock, lock.holders);
+	return slotWaitsOf(events).length > 0 ? "waiting for slot" : status;
+};
+/**
+* The `ork ps` table; `withProject` adds each run's project. A called run's
+* cost is dimmed and says its caller's, whose cost already counts it.
+*/
+const formatRuns = (runs, withProject, now = Date.now(), statusOf = liveStatus, term = termOf(process.stdout), yolo = () => false) => {
+	if (runs.length === 0) return ["No runs."];
+	const rows = runs.map((run) => {
+		const status = statusOf(run);
+		const end = run.finishedAt === void 0 ? now : Date.parse(run.finishedAt);
+		return {
+			id: run.id,
+			workflow: yolo(run) ? `${run.workflow} · yolo` : run.workflow,
+			yolo: yolo(run),
+			status,
+			when: `${ago(run.startedAt, now)} · ${duration(end - Date.parse(run.startedAt))}`,
+			cost: run.parent === void 0 ? costOf(run.costUsd, run.partial, run.tokens) : `${costOf(run.costUsd, run.partial, run.tokens)} in ${run.parent}`,
+			called: run.parent !== void 0,
+			project: run.project
+		};
+	});
+	const rowOf = (r) => {
+		const cells = [
+			{
+				text: r.id,
+				look: (s) => style("bold", s)
+			},
+			r.yolo ? {
+				text: r.workflow,
+				look: (s) => style("yellow", s)
+			} : { text: r.workflow },
+			{
+				text: r.status,
+				chip: statusChip(r.status),
+				look: (s) => style(STATUS_STYLE[r.status] ?? "reset", s)
+			},
+			{
+				text: r.when,
+				look: dim
+			},
+			r.called ? {
+				text: r.cost,
+				look: dim
+			} : { text: r.cost }
+		];
+		if (withProject) cells.push({
+			text: r.project,
+			look: dim
+		});
+		return cells;
+	};
+	const heads = [
+		"RUN",
+		"WORKFLOW",
+		"STATUS",
+		"STARTED",
+		"COST"
+	].map((text) => header(text));
+	if (withProject) heads.push(header("PROJECT"));
+	const columns = [
+		{},
+		{ flex: true },
+		{},
+		{},
+		{ align: "right" }
+	];
+	if (withProject) columns.push({ flex: true });
+	return table(term, columns, [heads, ...rows.map((row) => rowOf(row))]);
+};
+/** Marks are made when used, so `--plain` (set after load) is read. */
+const STATE_MARK = {
+	waiting: () => style("dim", "·"),
+	running: () => style("cyan", "●"),
+	ok: () => style("green", "✓"),
+	failed: () => style("red", "✗"),
+	skipped: () => style("dim", "-")
+};
+/** `950`, `12.3k`, `1.2M`. */
+const count = shortCount;
+const stateText = (node) => {
+	if (node.state === "running") return node.runs > 1 ? `running (round ${String(node.runs)})` : "running";
+	if (node.state === "ok" || node.state === "failed") {
+		const verdict = nodeVerdict(node.output ?? {}, node.state === "ok");
+		const line = verdict.length > 60 ? `${verdict.slice(0, 59)}…` : verdict;
+		return node.runs > 1 ? `${line} (${String(node.runs)} runs)` : line;
+	}
+	return node.state;
+};
+/** A node's counted tokens: input, output and cache write. */
+const countedOf = (node) => node.inputTokens + node.outputTokens + (node.cacheWriteTokens ?? 0);
+/**
+* What a node spent: its counted tokens, then dollars unless its driver reports
+* none, where `$0.00` would be false. Blank with no tokens.
+*/
+const worth = (node) => {
+	const counted = countedOf(node);
+	if (counted === 0) return "";
+	const tok = `${count(counted)} tok`;
+	return style("dim", `  ${node.unpriced === true ? tok : `${tok} · ${cost(node.costUsd)}`}`);
+};
+/**
+* A crashed run's node that never ended: cut off when it had started, not run
+* when it had not; `null` for one that ended.
+*/
+const crashedState = (node) => {
+	if (node.state === "running") return `${STATE_MARK.failed()} cut off`;
+	if (node.state === "waiting") return `${STATE_MARK.skipped()} not run`;
+	return null;
+};
+/**
+* The ownership tree, one line per node, children under their owner. A node in
+* `waits` (a live run's lock and slot waits) reads its line, an item too. In a
+* `crashed` run, a node started but not ended reads `cut off` and one not
+* started `not run`: nothing will end them.
+*/
+const formatTree = (roots, now = Date.now(), waits = [], crashed = false) => {
+	const lines = [];
+	const walk = (raw, lead, branch) => {
+		const node = raw.description === void 0 ? raw : {
+			...raw,
+			description: maskSecrets(raw.description)
+		};
+		const named = node.description === void 0 ? "" : `  ${node.description}`;
+		lines.push({
+			label: `${lead}${branch}${node.id}${named}`,
+			node
+		});
+		const next = lead + (branch === "├─ " ? "│  " : branch === "" ? "" : "   ");
+		node.children.forEach((child, index) => {
+			walk(child, next, index === node.children.length - 1 ? "└─ " : "├─ ");
+		});
+	};
+	for (const root of roots) walk(root, "", "");
+	const label = Math.max(...lines.map((l) => widthOf(l.label)));
+	const type = Math.max(...lines.map((l) => l.node.type.length));
+	return lines.map(({ label: text, node }) => {
+		const usage = worth(node);
+		const wait = waits.find((each) => each.id === node.id)?.line;
+		const cut = crashed ? crashedState(node) : null;
+		const state = cut ?? (node.held === true ? `${style("yellow", "‖")} paused` : wait === void 0 ? `${STATE_MARK[node.state]()} ${stateText(node)}` : `${STATE_MARK.waiting()} ${wait}`);
+		const spent = isItem(node) && node.startedAt !== void 0 && cut === null ? style("dim", `  ${duration((node.finishedAt === void 0 ? now : Date.parse(node.finishedAt)) - Date.parse(node.startedAt))}`) : "";
+		return `${node.description === void 0 ? text : `${text.slice(0, text.length - node.description.length)}${dim(node.description)}`}${" ".repeat(label - widthOf(text))}  ${style("dim", node.type.padEnd(type))}  ${state}${spent}${usage}`;
+	});
+};
+/**
+* What `ork tree` prints: the run's header (its status as `ork ps` reads it)
+* and the tree. A finished run's lock waits are stale, so only a live run's
+* show; `events` are the run's, `roots` its nested tree.
+*/
+const formatTreeView = (run, events, roots, now = Date.now()) => {
+	const status = runStatus(run, events);
+	const waits = status === "running" ? [...lockWaitsOf(events).map(({ id, lock }) => ({
+		id,
+		line: `waiting for ${lock}`
+	})), ...slotWaitingOf(events).map(({ id, holders }) => ({
+		id,
+		line: slotWaitLine(holders)
+	}))] : [];
+	const yolo = status === "running" && yoloOf(events) ? style("yellow", " · yolo") : "";
+	return [`${style("bold", `run ${run.id}`)} ${dim(`of ${run.workflow} · ${listedStatus(run, events)} · ${cost(run.costUsd)}`)}${yolo}`, ...formatTree(roots, now, waits, status === "crashed")];
+};
+export { header as a, listedStatus as i, formatRuns as n, table as o, formatTreeView as r, ago as t };

package/dist/{help-groups-BwYoAWsh.mjs → help-groups-BQvcKQ9H.mjs}

@@ -4,7 +4,9 @@
 *   shell. Each is thin: it runs `ork __complete -- <words…>` with the word
 *   under the cursor last, and offers the lines it prints, `value<TAB>
 *   description`. A line `:group <title>` starts a group (zsh labels the menu
-*   with it); `:files` asks for file names too. A new shell is one more entry.
+*   with it); `:files` asks for file names too. A value ending in `=` (an
+*   input's `name=`) takes no space after it, so its value is typed next. A new
+*   shell is one more entry.
 */
 /** The hidden command the scripts run. */
 const COMPLETE_COMMAND = "__complete";
@@ -15,9 +17,11 @@ const SHELL_SCRIPTS = {
 # (ork completion zsh > ~/.zsh/completions/_ork), or source it.
 
 _ork() {
-  local -a lines cands
-  local line group=commands files=0 n=0 ret=1
+  local -a lines cands opens
+  local line value said group=commands files=0 n=0 ret=1
   lines=("\${(@f)$("\${words[1]}" ${COMPLETE_COMMAND} -- "\${(@)words[2,CURRENT]}" 2>/dev/null)}")
+  # A last group line offers what the last group gathered.
+  lines+=(":group end")
   for line in "\${lines[@]}"; do
     case $line in
       (:files) files=1 ;;
@@ -25,15 +29,22 @@ _ork() {
         if (( \${#cands} )); then
           _describe -V -t "ork-$(( ++n ))" "$group" cands && ret=0
         fi
-        cands=()
+        # name= is followed by its value, not a space.
+        if (( \${#opens} )); then
+          _describe -V -t "ork-$(( ++n ))" "$group" opens -S '' && ret=0
+        fi
+        cands=() opens=()
         group=\${line#:group }
         ;;
-      (?*) cands+=("\${\${line%%$'\\t'*}//:/\\\\:}:\${line#*$'\\t'}") ;;
+      (?*)
+        value=\${\${line%%$'\\t'*}//:/\\\\:}
+        said=\${line#*$'\\t'}
+        # No description: the value alone, or zsh shows an empty one as --.
+        [[ $said == "$line" || -z $said ]] || value+=":$said"
+        if [[ $line == *=$'\\t'* ]]; then opens+=("$value"); else cands+=("$value"); fi
+        ;;
     esac
   done
-  if (( \${#cands} )); then
-    _describe -V -t "ork-$(( ++n ))" "$group" cands && ret=0
-  fi
   if (( files )); then
     _files && ret=0
   fi
@@ -48,9 +59,10 @@ fi
 `,
 	bash: `# Tab completion for ork, in bash. Add to your ~/.bashrc:
 #   eval "$(ork completion bash)"
-# (macOS's bash 3.2 can't source <(…); saving it to a file and sourcing that
-# works too.) Every expansion is quoted and lines are read with read -r, so a
-# candidate is never split or glob-expanded.
+# (macOS's bash 3.2 loads nothing from source <(…), and prints no error;
+# saving it to a file and sourcing that works in every version.) Every
+# expansion is quoted and lines are read with read -r, so a candidate is never
+# split or glob-expanded.
 
 _ork() {
   local line="\${COMP_LINE:0:COMP_POINT}" cur files=0 strip="" out
@@ -59,10 +71,15 @@ _ork() {
   if [[ "$line" == *[[:space:]] ]]; then words+=(""); fi
   cur="\${words[\${#words[@]}-1]}"
   COMPREPLY=()
-  # bash splits a word at ":" (ork:feature); offer only what follows it.
-  if [[ "$cur" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then
-    strip="\${cur%"\${cur##*:}"}"
-  fi
+  # bash splits a word at ":" and "=" (ork:feature, --input=plan=); offer only
+  # what follows the last of them that is a word break.
+  local brk pre
+  for brk in : =; do
+    if [[ "$cur" == *"$brk"* && "$COMP_WORDBREAKS" == *"$brk"* ]]; then
+      pre="\${cur%"\${cur##*"$brk"}"}"
+      if (( \${#pre} > \${#strip} )); then strip="$pre"; fi
+    fi
+  done
   out="$("\${words[0]}" ${COMPLETE_COMMAND} -- "\${words[@]:1}" 2>/dev/null)"
   while IFS= read -r line; do
     case "$line" in
@@ -71,6 +88,10 @@ _ork() {
       *)
         line="\${line%%$'\\t'*}"
         COMPREPLY+=("\${line#"$strip"}")
+        # name= is followed by its value, not a space (bash 4 and later).
+        if [[ "$line" == *= ]] && type compopt &>/dev/null; then
+          compopt -o nospace
+        fi
         ;;
     esac
   done <<< "$out"
@@ -103,68 +124,6 @@ complete -c ork -f -a '(__ork_complete)'
 };
 /** The shells there is a script for. */
 const SHELLS = Object.keys(SHELL_SCRIPTS);
-// src/command-tree.ts
-/** How a flag that only Ork passes to itself starts its description. */
-const INTERNAL = "Internal:";
-/** Whether citty was given a function that gives the value. */
-const isThunk = (value) => typeof value === "function";
-/** A value citty lets be given as is, as a promise, or as a function. */
-const resolved = (value) => Promise.resolve(isThunk(value) ? value() : value);
-/** `args` without the flags only Ork passes to itself. */
-const publicArgs = (args) => Object.fromEntries(Object.entries(args).filter(([, def]) => !(def.description ?? "").startsWith(INTERNAL)));
-/** A command's flags and positionals, which citty lets be given lazily. */
-const argsOf = (cmd) => cmd.args === void 0 ? Promise.resolve({}) : resolved(cmd.args);
-const listOf = (value) => value === void 0 ? [] : [value].flat();
-const flagOf = (name, def) => ({
-	name,
-	description: def.description ?? "",
-	takesValue: def.type === "string" || def.type === "enum",
-	aliases: "alias" in def ? listOf(def.alias) : [],
-	options: def.type === "enum" ? def.options ?? [] : [],
-	negatable: def.type === "boolean" && def.default === true
-});
-/** A command's public flags and positionals, in the order it defines them. */
-const argInfoOf = async (cmd) => {
-	const entries = Object.entries(publicArgs(await argsOf(cmd)));
-	return {
-		flags: entries.filter(([, def]) => def.type !== "positional").map(([name, def]) => flagOf(name, def)),
-		positionals: entries.filter(([, def]) => def.type === "positional").map(([name, def]) => ({
-			name,
-			description: def.description ?? ""
-		}))
-	};
-};
-/**
-* A command's subcommands, in order, loaded ones resolved. A name whose
-* definition is one listed before it (`wt`, `worktrees`'s) is an alias of that
-* one, not an entry of its own.
-*/
-const subcommandsOf = async (cmd) => {
-	const subs = cmd.subCommands === void 0 ? {} : await resolved(cmd.subCommands);
-	const loaded = await Promise.all(Object.entries(subs).map(async ([name, sub]) => {
-		const def = await resolved(sub);
-		return {
-			name,
-			def,
-			meta: def.meta === void 0 ? {} : await resolved(def.meta)
-		};
-	}));
-	const entries = [];
-	for (const { name, def, meta } of loaded) {
-		const same = entries.find((entry) => entry.def === def);
-		if (same === void 0) entries.push({
-			name,
-			aliases: listOf(meta.alias),
-			description: meta.description ?? "",
-			hidden: meta.hidden === true,
-			def
-		});
-		else same.aliases.push(name);
-	}
-	return entries;
-};
-/** The subcommand `name` (or one of its aliases) of `entries`. */
-const findEntry = (entries, name) => entries.find((entry) => entry.name === name || entry.aliases.includes(name));
 // src/help-groups.ts
 const HELP_GROUPS = [
 	{
@@ -220,6 +179,10 @@ const HELP_GROUPS = [
 				name: "logs",
 				short: "Print a run's transcript"
 			},
+			{
+				name: "attach",
+				short: "Follow a run here and answer its questions"
+			},
 			{
 				name: "tree",
 				short: "Show a run's tree, tokens and cost"
@@ -270,6 +233,10 @@ const HELP_GROUPS = [
 				name: "feedback",
 				short: "What got in the way in your runs"
 			},
+			{
+				name: "follow-ups",
+				short: "What shipped changes left for later"
+			},
 			{
 				name: "worktrees",
 				short: "Track and clean up Ork's worktrees"
@@ -316,6 +283,10 @@ const HELP_GROUPS = [
 				name: "send",
 				short: "Write to a session from a tool node's program"
 			},
+			{
+				name: "once",
+				short: "Run a check unless it passed on these files"
+			},
 			{
 				name: "completion",
 				short: "Print a tab-completion script"
@@ -351,4 +322,4 @@ const groupedEntries = (entries) => {
 		entries: other
 	}].filter((group) => group.entries.length > 0);
 };
-export { findEntry as a, subcommandsOf as c, SHELL_SCRIPTS as d, argsOf as i, COMPLETE_COMMAND as l, groupedEntries as n, publicArgs as o, argInfoOf as r, resolved as s, groupOf as t, SHELLS as u };
+export { SHELL_SCRIPTS as a, SHELLS as i, groupedEntries as n, COMPLETE_COMMAND as r, groupOf as t };

package/dist/in-a-run-D_wg4iJi.mjs

@@ -0,0 +1,27 @@
+import { z as storePath } from "./src-BuF9Lbow.mjs";
+import { g as storeGuarded, h as runMarkerIn } from "./src-k0A_QpST.mjs";
+// src/commands/in-a-run.ts
+/**
+* @file The commands that act as the user refuse a program or an agent in a run
+*   (ADR-047), in the stores that run guards: the store of a nested run under a
+*   temp HOME is not guarded unless an enclosing run lists it. The refusal
+*   names the variable it saw, for someone at their own terminal who inherited
+*   it. It stops accidents; it is not a boundary.
+*/
+const refusal = (why, env, store) => {
+	const marker = runMarkerIn(env);
+	return marker === null || !storeGuarded(env, store) ? null : `${why} ${marker} is set here. If this is your own terminal, it inherited that from a program in a run (a tmux server started by one, say); open a shell without it.`;
+};
+/** Why `ork watch --accept` refuses here, or `null` when it may run. */
+const acceptRefusal = (env = process.env, store = storePath()) => refusal("`ork watch --accept` approves code to run with nobody there, so a program or an agent in a run cannot use it.", env, store);
+/** Why `ork chat` refuses here, or `null` when it may run. */
+const chatRefusal = (env = process.env, store = storePath()) => refusal("`ork chat` speaks as you, so a program or an agent in a run cannot use it. A program writes to a session with `ork send`.", env, store);
+/** Why `ork decide` will not answer here, or `null` when it may. */
+const decideRefusal = (env = process.env, store = storePath()) => refusal("`ork decide` answers as you, so a program or an agent in a run cannot answer with it; `ork decide --list` still shows what is open.", env, store);
+/** Why `ork continue` refuses here, or `null` when it may run. */
+const continueRefusal = (env = process.env, store = storePath()) => refusal("`ork continue` undoes a pause you set, so a program or an agent in a run cannot use it.", env, store);
+/** Whether `ork ui` may print its sign-in link, which acts as the user. */
+const mayShowSignIn = (env = process.env, store = storePath()) => !storeGuarded(env, store);
+/** Why `ork attach` will not answer here, or `null` when it may. */
+const attachRefusal = (env = process.env, store = storePath()) => refusal("`ork attach` answers as you, so a program or an agent in a run cannot use it; `ork logs` still shows the run.", env, store);
+export { decideRefusal as a, continueRefusal as i, attachRefusal as n, mayShowSignIn as o, chatRefusal as r, acceptRefusal as t };