@krapht/ork 0.3.0 → 1.0.0-alpha.0

package/dist/help-groups-BwYoAWsh.mjs

@@ -0,0 +1,354 @@
+// src/completion/scripts.ts
+/**
+* @file The tab-completion scripts `ork completion <shell>` prints, one per
+*   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.
+*/
+/** The hidden command the scripts run. */
+const COMPLETE_COMMAND = "__complete";
+/** Each shell's script, by the name `ork completion` takes. */
+const SHELL_SCRIPTS = {
+	zsh: `#compdef ork
+# Tab completion for ork, in zsh. Save it as _ork in a folder on your fpath
+# (ork completion zsh > ~/.zsh/completions/_ork), or source it.
+
+_ork() {
+  local -a lines cands
+  local line group=commands files=0 n=0 ret=1
+  lines=("\${(@f)$("\${words[1]}" ${COMPLETE_COMMAND} -- "\${(@)words[2,CURRENT]}" 2>/dev/null)}")
+  for line in "\${lines[@]}"; do
+    case $line in
+      (:files) files=1 ;;
+      (:group\\ *)
+        if (( \${#cands} )); then
+          _describe -V -t "ork-$(( ++n ))" "$group" cands && ret=0
+        fi
+        cands=()
+        group=\${line#:group }
+        ;;
+      (?*) cands+=("\${\${line%%$'\\t'*}//:/\\\\:}:\${line#*$'\\t'}") ;;
+    esac
+  done
+  if (( \${#cands} )); then
+    _describe -V -t "ork-$(( ++n ))" "$group" cands && ret=0
+  fi
+  if (( files )); then
+    _files && ret=0
+  fi
+  return ret
+}
+
+if [[ "\${funcstack[1]}" == _ork ]]; then
+  _ork "$@"
+else
+  compdef _ork ork
+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.
+
+_ork() {
+  local line="\${COMP_LINE:0:COMP_POINT}" cur files=0 strip="" out
+  local -a words
+  read -r -a words <<< "$line"
+  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
+  out="$("\${words[0]}" ${COMPLETE_COMMAND} -- "\${words[@]:1}" 2>/dev/null)"
+  while IFS= read -r line; do
+    case "$line" in
+      :files) files=1 ;;
+      :* | "") ;;
+      *)
+        line="\${line%%$'\\t'*}"
+        COMPREPLY+=("\${line#"$strip"}")
+        ;;
+    esac
+  done <<< "$out"
+  if (( files )); then
+    out="$(compgen -f -- "$cur")"
+    while IFS= read -r line; do
+      if [[ -n "$line" ]]; then COMPREPLY+=("\${line#"$strip"}"); fi
+    done <<< "$out"
+  fi
+}
+
+complete -F _ork ork
+`,
+	fish: `# Tab completion for ork, in fish. Save it as
+# ~/.config/fish/completions/ork.fish (ork completion fish > …), or source it.
+
+function __ork_complete
+    # -x is fish 4's name for -o, which it deprecates; fish 3 has only -o.
+    set -l tokens (commandline -xpc 2>/dev/null; or commandline -opc)
+    set -l current (commandline -ct)
+    set -l out ($tokens[1] ${COMPLETE_COMMAND} -- $tokens[2..-1] "$current" 2>/dev/null)
+    string match -v -r '^:' -- $out
+    if contains -- :files $out
+        __fish_complete_path "$current"
+    end
+end
+
+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 = [
+	{
+		title: "Get started",
+		commands: [
+			{
+				name: "init",
+				short: "Set up Ork in this repository, in .ork/"
+			},
+			{
+				name: "doctor",
+				short: "Check Node, git and your own logins"
+			},
+			{
+				name: "ui",
+				short: "Open Ork's local UI in the browser"
+			}
+		]
+	},
+	{
+		title: "Workflows",
+		commands: [
+			{
+				name: "validate",
+				short: "Check workflow files"
+			},
+			{
+				name: "run",
+				short: "Run a workflow, or one node of it"
+			},
+			{
+				name: "agents",
+				short: "List, show, add and remove agents"
+			},
+			{
+				name: "context",
+				short: "Show what a node's session loads"
+			},
+			{
+				name: "watch",
+				short: "Start runs from each project's triggers"
+			}
+		]
+	},
+	{
+		title: "Runs",
+		commands: [
+			{
+				name: "ps",
+				short: "List this project's runs"
+			},
+			{
+				name: "logs",
+				short: "Print a run's transcript"
+			},
+			{
+				name: "tree",
+				short: "Show a run's tree, tokens and cost"
+			},
+			{
+				name: "usage",
+				short: "Show what runs spent over time"
+			},
+			{
+				name: "resume",
+				short: "Continue a run that didn't succeed"
+			}
+		]
+	},
+	{
+		title: "Steer a running run",
+		commands: [
+			{
+				name: "decide",
+				short: "Answer a run's open decisions"
+			},
+			{
+				name: "chat",
+				short: "Talk to a node of a run"
+			},
+			{
+				name: "pause",
+				short: "Pause a run, or one node"
+			},
+			{
+				name: "continue",
+				short: "Let a paused run or node go on"
+			},
+			{
+				name: "stop",
+				short: "Stop a run, or one node"
+			},
+			{
+				name: "relay",
+				short: "Let nodes of two runs message each other"
+			}
+		]
+	},
+	{
+		title: "After runs",
+		commands: [
+			{
+				name: "feedback",
+				short: "What got in the way in your runs"
+			},
+			{
+				name: "worktrees",
+				short: "Track and clean up Ork's worktrees"
+			},
+			{
+				name: "prune",
+				short: "Forget old runs' transcripts"
+			}
+		]
+	},
+	{
+		title: "Projects",
+		commands: [
+			{
+				name: "projects",
+				short: "List, forget or move registered projects"
+			},
+			{
+				name: "register",
+				short: "Attach a project from outside it"
+			},
+			{
+				name: "migrate",
+				short: "Move an attached project into its .ork/"
+			},
+			{
+				name: "link",
+				short: "Point tools' agent folders at .ork/"
+			}
+		]
+	},
+	{
+		title: "Ork itself",
+		commands: [
+			{
+				name: "upgrade",
+				short: "Upgrade Ork, the way it was installed"
+			},
+			{
+				name: "mcp",
+				short: "Serve Ork's tools to Claude Code (MCP)"
+			},
+			{
+				name: "send",
+				short: "Write to a session from a tool node's program"
+			},
+			{
+				name: "completion",
+				short: "Print a tab-completion script"
+			}
+		]
+	}
+];
+/** What a command not in any group is listed under. */
+const OTHER_GROUP = "Other";
+/** The group a root command is in, and its short line, if it has them. */
+const groupOf = (name) => {
+	for (const group of HELP_GROUPS) {
+		const found = group.commands.find((command) => command.name === name);
+		if (found !== void 0) return {
+			title: group.title,
+			short: found.short
+		};
+	}
+};
+/**
+* The shown commands in `HELP_GROUPS`'s order, then any in no group under
+* "Other", in the order the root command lists them.
+*/
+const groupedEntries = (entries) => {
+	const shown = entries.filter((entry) => !entry.hidden);
+	const grouped = HELP_GROUPS.map((group) => ({
+		title: group.title,
+		entries: group.commands.flatMap((command) => shown.find((entry) => entry.name === command.name) ?? [])
+	}));
+	const other = shown.filter((entry) => groupOf(entry.name) === void 0);
+	return [...grouped, {
+		title: OTHER_GROUP,
+		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 };

package/dist/{in-a-run-BbLhZOFW.mjs → in-a-run-BPXX09Bs.mjs}

@@ -1,4 +1,4 @@
-import { p as runMarkerIn } from "./src-DtN1k-B3.mjs";
+import { p as runMarkerIn } from "./src-C38BPzit.mjs";
 // src/commands/in-a-run.ts
 /**
 * @file The commands that act as the user refuse a program or an agent in a run

package/dist/{limits-BKYAmqCR.mjs → limits-JCve2QpI.mjs}

@@ -1,4 +1,4 @@
-import { a as limitsNow, i as NOT_STARTED, o as limitsReport, r as capsHere } from "./src-Cz1yOUTg.mjs";
+import { a as limitsNow, i as NOT_STARTED, o as limitsReport, r as capsHere } from "./src-DHvWU4tX.mjs";
 // src/run/limits.ts
 /**
 * @file The limits across runs that apply here (RFC-007): the user's settings

package/dist/list-C7UEgmtd.mjs

@@ -0,0 +1,110 @@
+import { A as gitOk, j as lines, k as git } from "./src-DHvWU4tX.mjs";
+import { existsSync } from "node:fs";
+// ../core/src/worktree/list.ts
+/**
+* @file What `ork worktrees` shows: every worktree and branch Ork's runs
+*   recorded creating, whatever the project's git rules named them, and any
+*   `ork/*` branch besides, with their state read from git itself. What clean
+*   and remove do with them is clean.ts.
+*/
+/**
+* The worktrees the project's runs recorded creating, oldest run first; one
+* entry per branch or folder, from the latest run that created it.
+*/
+const createdWorktrees = (store, project) => {
+	const byName = /* @__PURE__ */ new Map();
+	for (const run of store.runs({ project }).toReversed()) for (const { event } of store.events(run.id)) {
+		if (event.type !== "worktree" || event.action !== "created") continue;
+		byName.set(event.branch ?? event.path, {
+			runId: run.id,
+			nodeId: event.id,
+			path: event.path,
+			...event.branch === void 0 ? {} : { branch: event.branch }
+		});
+	}
+	return [...byName.values()];
+};
+const parsePorcelain = (text) => text.split("\n\n").map((block) => lines(block)).map((fields) => {
+	const value = (key) => fields.find((f) => f.startsWith(`${key} `))?.slice(key.length + 1);
+	return {
+		path: value("worktree") ?? "",
+		branch: (value("branch") ?? "").replace(/^refs\/heads\//u, ""),
+		prunable: fields.some((f) => f.startsWith("prunable"))
+	};
+}).filter((entry) => entry.path !== "");
+/**
+* The `ork/<run>/<node>` branches of runs that recorded nothing; with no path
+* recorded, the worktree is whichever has the branch checked out.
+*/
+const prefixed = (branch) => {
+	const [, runId = "", ...rest] = branch.split("/");
+	return {
+		runId,
+		nodeId: rest.join("/"),
+		path: "",
+		branch
+	};
+};
+/** How many commits a detached worktree holds that no branch, tag or remote has. */
+const onNoBranch = async (entry) => entry === void 0 ? "0" : (await git(entry.path, [
+	"rev-list",
+	"--count",
+	"HEAD",
+	"--not",
+	"--branches",
+	"--tags",
+	"--remotes"
+])).stdout;
+/** One created worktree or branch, with its state read from git. */
+const stateOf = async (root, entries, item) => {
+	const { branch } = item;
+	const entry = branch === void 0 || item.path !== "" ? entries.find((e) => e.path === item.path) : entries.find((e) => e.branch === branch);
+	const holder = branch === void 0 ? void 0 : entries.find((e) => e.branch === branch && e.path !== entry?.path);
+	const missing = entry !== void 0 && (entry.prunable || !existsSync(entry.path));
+	const status = entry === void 0 || missing ? "" : (await git(entry.path, ["status", "--porcelain"])).stdout;
+	const checkedOut = branch === void 0 && entry !== void 0 && entry.branch !== "" ? entry.branch : void 0;
+	const on = branch ?? checkedOut;
+	const counted = on === void 0 ? await onNoBranch(entry === void 0 || missing ? void 0 : entry) : (await git(root, [
+		"rev-list",
+		"--count",
+		`HEAD..${on}`
+	])).stdout;
+	const ahead = Number(counted);
+	const changes = lines(status).length;
+	return {
+		...branch === void 0 ? {} : { branch },
+		...checkedOut === void 0 ? {} : { checkedOut },
+		runId: item.runId,
+		nodeId: item.nodeId,
+		path: entry?.path ?? null,
+		missing,
+		dirty: changes > 0,
+		changes,
+		ahead: Number.isNaN(ahead) ? 0 : ahead,
+		merged: on !== void 0 && ahead === 0,
+		inMainCheckout: entry?.path === root || holder?.path === root,
+		...holder === void 0 || holder.path === root ? {} : { heldBy: holder.path }
+	};
+};
+/**
+* Every worktree and branch Ork's runs created in the repository at `root`,
+* with its state: those the runs recorded (`created`, whatever the project's
+* git rules named them), and any `ork/` branch besides. A recorded one that git
+* no longer has is left out.
+*/
+const listOrkWorktrees = async (root, created = []) => {
+	const entries = parsePorcelain(await gitOk(root, [
+		"worktree",
+		"list",
+		"--porcelain"
+	]));
+	const branches = lines(await gitOk(root, [
+		"for-each-ref",
+		"--format=%(refname:short)",
+		"refs/heads/"
+	]));
+	const recordedBranches = new Set(created.flatMap((c) => c.branch ?? []));
+	const items = [...created.filter((c) => c.branch === void 0 ? entries.some((e) => e.path === c.path) : branches.includes(c.branch)), ...branches.filter((b) => b.startsWith("ork/") && !recordedBranches.has(b)).map((b) => prefixed(b))];
+	return Promise.all(items.map((item) => stateOf(root, entries, item)));
+};
+export { listOrkWorktrees as n, createdWorktrees as t };

package/dist/{mcp-BWsdQyri.mjs → mcp-CKPyNaKD.mjs}

@@ -1,10 +1,10 @@
-import "./src-Cz1yOUTg.mjs";
-import { n as ORK_VERSION } from "./__build_info__-CXXMLvjt.mjs";
-import { a as openMcp, c as refused, o as tool, s as answer } from "./src-D5ruZFgD.mjs";
-import { n as explainNode, p as isNewer } from "./context-BFGC_C02.mjs";
-import { p as runMarkerIn } from "./src-DtN1k-B3.mjs";
-import { defineCommand } from "citty";
+import { h as isNewer } from "./src-DHvWU4tX.mjs";
+import { n as ORK_VERSION } from "./__build_info__-DdTVd2p5.mjs";
+import { a as openMcp, c as refused, o as tool, s as answer } from "./src-BJTegEzY.mjs";
+import { n as explainNode } from "./context-DO3sBy9v.mjs";
+import { p as runMarkerIn } from "./src-C38BPzit.mjs";
 import { z } from "zod";
+import { defineCommand } from "citty";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 // src/commands/mcp.ts
@@ -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, "0.3.0") ? tooOld(all, options.expects) : all;
+	const tools = options.expects !== void 0 && isNewer(options.expects, "1.0.0-alpha.0") ? tooOld(all, options.expects) : all;
 	const server = new McpServer({
 		name: "ork",
 		version: ORK_VERSION