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

package/dist/brief-za0ozN_E.mjs

@@ -0,0 +1,58 @@
+import { un as takeFollowUps } from "./src-Dr_fTSu-.mjs";
+import { l as briefOf, n as flagValues, u as checkTakeable } from "./run--4-1xAF2.mjs";
+import { n as newRunId } from "./find-BYLlszqj.mjs";
+import { l as writeErr } from "./output-B1kwo0YU.mjs";
+import { t as loadWorkflow } from "./validate-Bs_gg22g.mjs";
+// src/follow-ups/brief.ts
+/**
+* @file `ork run --follow-ups <ids>`: the `agent` follow-ups become the run's
+*   `brief` input, and are marked taken by the run, which finishes them when it
+*   publishes (`ork follow-ups published`). Everything that could refuse them
+*   (an unknown id, one for someone else, a workflow with no `brief` input) is
+*   checked before any is marked, so a run that doesn't start leaves them be.
+*/
+/** The ids `--follow-ups` was given, one per comma or repeat. */
+const idsOf = (rawArgs) => flagValues(rawArgs, "--follow-ups").flatMap((value) => value.split(",")).map((id) => id.trim()).filter((id) => id !== "");
+/**
+* What stops `--follow-ups` from starting a run, one line each; none when
+* nothing does.
+*/
+const problemsOf = (loaded, inputs) => {
+	const name = loaded.workflow?.name ?? "";
+	if (loaded.workflow?.inputs?.["brief"] === void 0) return [`--follow-ups fills a workflow's \`brief\` input, and ${name} has none.`];
+	return inputs.some((input) => input.startsWith("brief=")) ? ["--follow-ups and --input brief=… both set the brief."] : [];
+};
+/**
+* The inputs and run id `ork run` starts with: those it was given and, for
+* `--follow-ups`, a `brief` made of the follow-ups with the id of the run that
+* takes them. `undefined` after saying why it can't start.
+*/
+const prepareFollowUps = (store, rawArgs, runId, target) => {
+	const inputs = flagValues(rawArgs, "--input");
+	const ids = idsOf(rawArgs);
+	const plain = {
+		inputs,
+		...runId === void 0 ? {} : { runId }
+	};
+	if (ids.length === 0) return plain;
+	const loaded = loadWorkflow(target.file, process.cwd(), void 0, store.projects());
+	if (loaded.workflow === null) return plain;
+	const takeable = checkTakeable(store, loaded.place.root, ids);
+	const problems = [...problemsOf(loaded, inputs), ...takeable.ok ? [] : takeable.lines];
+	if (!takeable.ok || problems.length > 0) {
+		for (const line of problems) writeErr(line);
+		process.exitCode = 1;
+		return;
+	}
+	const taker = runId ?? newRunId(store);
+	takeFollowUps(store, {
+		project: loaded.place.root,
+		run: taker,
+		ids: takeable.followUps.map((f) => f.id)
+	});
+	return {
+		inputs: [...inputs, `brief=${briefOf(takeable.followUps)}`],
+		runId: taker
+	};
+};
+export { prepareFollowUps };

package/dist/{builtin-files-n6o6oWpB.mjs → builtin-files-2bHf76x-.mjs}

@@ -1,4 +1,4 @@
-import { $n as plainPathInside, Hn as placeFiles, Qn as guardedBase, er as writePlainFile } from "./src-BeR6f70A.mjs";
+import { Er as placeFiles, Ir as guardedBase, Lr as plainPathInside, Rr as writePlainFile } from "./src-Dr_fTSu-.mjs";
 import path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { createHash } from "node:crypto";

package/dist/{chips-CyeB_rhR.mjs → chips-BqcT58qr.mjs}

@@ -1,4 +1,4 @@
-import { d as apply, l as CHIP, u as NODE_PALETTE } from "./output-CnRzrbUM.mjs";
+import { d as CHIP, f as NODE_PALETTE, p as apply } from "./output-B1kwo0YU.mjs";
 // src/term/chips.ts
 /** The chip words the kit's commands use. */
 const CHIP_LABELS = {

package/dist/{completion-SNNNxnv9.mjs → completion-CQ2UYKuJ.mjs}

@@ -1,10 +1,9 @@
-import { Hn as placeFiles, Nr as AGENT_DRIVERS, Sr as NodeIdSchema, T as storePath, Un as placeFor, _t as liveStatus, w as openStore } from "./src-BeR6f70A.mjs";
-import { a as isBuiltinArg, i as builtinWorkflowText, r as builtinWorkflowNames } from "./builtin-files-n6o6oWpB.mjs";
-import { n as pendingDecisions } from "./decide-DuIHACvH.mjs";
-import { t as findRun } from "./find-CjsNYAAf.mjs";
-import { a as findEntry, c as subcommandsOf, d as SHELL_SCRIPTS, l as COMPLETE_COMMAND, n as groupedEntries, r as argInfoOf, t as groupOf, u as SHELLS } from "./help-groups-CyfPWlST.mjs";
-import { s as writeErr } from "./output-CnRzrbUM.mjs";
-import { a as resolveWorkflowArg, n as WORKFLOW_SUFFIX } from "./workflows-7tQdMnrA.mjs";
+import { Cn as liveStatus, Dr as placeFor, Er as placeFiles, U as openStore, W as storePath, _i as AGENT_DRIVERS, oi as NodeIdSchema, ut as pendingDecisions } from "./src-Dr_fTSu-.mjs";
+import { a as isBuiltinArg, i as builtinWorkflowText, r as builtinWorkflowNames } from "./builtin-files-2bHf76x-.mjs";
+import { t as findRun } from "./find-BYLlszqj.mjs";
+import { a as findEntry, c as subcommandsOf, d as SHELL_SCRIPTS, l as COMPLETE_COMMAND, n as groupedEntries, r as argInfoOf, t as groupOf, u as SHELLS } from "./help-groups-CQ98mLjF.mjs";
+import { l as writeErr } from "./output-B1kwo0YU.mjs";
+import { a as resolveWorkflowArg, n as WORKFLOW_SUFFIX } from "./workflows-CW28ZU-z.mjs";
 import path from "node:path";
 import { parse } from "yaml";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
@@ -40,16 +39,45 @@ const workflowText = (arg, cwd, place) => {
 	const file = path.resolve(cwd, resolveWorkflowArg(arg, cwd, placeFiles(place).workflows));
 	return existsSync(file) && statSync(file).isFile() ? readFileSync(file, "utf8") : void 0;
 };
+/** A mapping's entries, or none when `value` is not an object. */
+const entriesOf = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? Object.entries(value) : [];
+/** One top-level field of a workflow's text, read without validating it. */
+const fieldOf = (text, field) => {
+	const parsed = text === void 0 ? void 0 : parse(text);
+	return Object.fromEntries(entriesOf(parsed))[field];
+};
 /** The node ids of the workflow `arg` names; none when it can't be read. */
 const workflowNodes = (arg, cwd, place) => {
-	const text = workflowText(arg, cwd, place);
-	const parsed = text === void 0 ? void 0 : parse(text);
-	const nodes = parsed !== null && typeof parsed === "object" && "nodes" in parsed ? parsed.nodes : void 0;
-	return (nodes !== null && typeof nodes === "object" ? Object.keys(nodes) : []).filter((key) => NodeIdSchema.safeParse(key).success).map((value) => ({
+	return entriesOf(fieldOf(workflowText(arg, cwd, place), "nodes")).map(([key]) => key).filter((key) => NodeIdSchema.safeParse(key).success).map((value) => ({
 		value,
 		description: arg
 	}));
 };
+/** What a menu says of an input: its description, else its type. */
+const inputDescription = (definition) => {
+	const fields = Object.fromEntries(entriesOf(definition));
+	const said = fields["description"] ?? fields["type"];
+	const what = typeof said === "string" ? said : "";
+	return fields["required"] === true && !("default" in fields) ? `${what} (required)` : what;
+};
+/**
+* `name=` for each input a workflow's text declares, for `--input`; a name that
+* isn't a valid id is left out, as a node's is.
+*/
+const inputsOf = (text, workflow) => entriesOf(fieldOf(text, "inputs")).filter(([name]) => NodeIdSchema.safeParse(name).success).map(([name, definition]) => ({
+	value: `${name}=`,
+	description: inputDescription(definition) || workflow
+}));
+/** The inputs of the workflow `arg` names; none when it can't be read. */
+const workflowInputs = (arg, cwd, place) => inputsOf(workflowText(arg, cwd, place), arg);
+/** The inputs of the run `arg` names (else the project's newest run). */
+const runInputs = (store, arg, cwd) => {
+	const found = findRun(store, arg, cwd);
+	if (!found.ok) return [];
+	const { file, workflow } = found.run;
+	const text = existsSync(file) && statSync(file).isFile() ? readFileSync(file, "utf8") : void 0;
+	return inputsOf(text, workflow);
+};
 /**
 * Runs whose id starts with `prefix`, newest first: the project's, else any
 * project's, at most `RUN_LIMIT`.
@@ -112,6 +140,18 @@ const nodes = {
 		return withStore(context, (store) => runNodes(store, context.given["run"], context.cwd));
 	}
 };
+/**
+* `name=` for each input, for `--input`: the workflow given's when the command
+* takes a workflow (none before it is), else the run given's (`ork resume`).
+*/
+const inputs = {
+	group: "inputs",
+	values: (context) => {
+		const workflow = context.given["workflow"];
+		if (context.positionals.includes("workflow")) return workflow === void 0 ? [] : workflowInputs(workflow, context.cwd, placeOf(context.cwd, context.store()));
+		return withStore(context, (store) => runInputs(store, context.given["run"], context.cwd));
+	}
+};
 const decisions = {
 	group: "decisions",
 	values: (context) => withStore(context, (store) => decisionCandidates(store, context.given["run"], context.cwd, placeOf(context.cwd, store)))
@@ -144,6 +184,7 @@ const VALUE_PROVIDERS = {
 		files: true
 	},
 	node: nodes,
+	input: inputs,
 	"decide id": decisions,
 	"completion shell": shells,
 	driver: drivers,

package/dist/context-BNqDw9z1.mjs

@@ -0,0 +1,106 @@
+import { Pr as LESSON_CAP_TOKENS, wt as explainSession } from "./src-Dr_fTSu-.mjs";
+import { c as write, s as style } from "./output-B1kwo0YU.mjs";
+import { i as refusedBuiltin, o as workflowArg } from "./workflows-CW28ZU-z.mjs";
+import { a as formatReport, t as loadWorkflow } from "./validate-Bs_gg22g.mjs";
+import { defineCommand } from "citty";
+// src/commands/context.ts
+/**
+* @file `ork context explain <wf> <node>`: what one node's session would load,
+*   layer by layer, as core's `explainSession` plans it without writing
+*   anything (one of Ork's own `ork:` workflows is written into the project's
+*   run folder first, as `ork run` does): its project instructions, every skill
+*   with the layer it came from and whether it is live, shadowed or switched
+*   off, its context files, its practices, and estimated tokens.
+*/
+/** Loads a workflow file and plans one node's session in it, in place. */
+const explainNode = (file, nodeId, cwd, home) => {
+	const { report, workflow, graph, place, workflowDir } = loadWorkflow(file, cwd, home);
+	if (workflow === null) return {
+		ok: false,
+		lines: formatReport(report)
+	};
+	const result = explainSession(workflow, graph, nodeId, {
+		root: place.root,
+		orkDir: place.dir,
+		workflowDir,
+		...home === void 0 ? {} : { home }
+	});
+	return result.ok ? result : {
+		ok: false,
+		lines: [result.error]
+	};
+};
+const approx = (count) => style("dim", `≈${count.toLocaleString("en")} tokens`);
+const formatExplanation = (e) => {
+	const width = Math.max(8, ...e.skills.map((s) => s.name.length));
+	const sourceWidth = Math.max(0, ...e.skills.map((s) => s.source.length));
+	const lines = [
+		`${style("bold", e.node)} ${style("dim", `(${e.type}) in ${e.workflow}`)}${e.template === void 0 ? "" : style("dim", `, planned as ${e.template}, the node it was spawned from`)}`,
+		"",
+		...e.agent === void 0 ? [] : [`${style("bold", "Agent")}  ${e.agent.name} ${style("dim", `(${e.agent.where})`)}  ${approx(e.agent.tokens)}`],
+		`${style("bold", "Instructions")}  ${e.instructions}`,
+		"",
+		style("bold", "Skills")
+	];
+	if (e.skills.length === 0) lines.push(style("dim", "  none"));
+	for (const s of e.skills) {
+		const mark = s.state === "live" ? style("green", "✓") : style("dim", "−");
+		const state = s.why === void 0 ? approx(s.tokens).replace("tokens", "tokens when used") : style("yellow", `off: ${s.why}`);
+		lines.push(`  ${mark} ${s.name.padEnd(width)}  ${s.layer.padEnd(8)}  ${style("dim", s.source.padEnd(sourceWidth))}  ${state}`);
+	}
+	lines.push("", style("bold", "Context files"));
+	if (e.files.length === 0) lines.push(style("dim", "  none"));
+	for (const f of e.files) {
+		const cut = f.cutFrom === void 0 ? "" : `  ${style("yellow", `cut at the ${LESSON_CAP_TOKENS.toLocaleString("en")}-token cap; the whole file is ${approx(f.cutFrom)}`)}`;
+		lines.push(`  ${f.layer.padEnd(8)}  ${f.name}  ${approx(f.tokens)}${cut}`);
+	}
+	lines.push("", style("bold", "Practices"));
+	for (const p of e.practices) lines.push(`  ${p.name.padEnd(8)}  ${approx(p.tokens)}`);
+	for (const name of e.skippedPractices) lines.push(`  ${name.padEnd(8)}  ${style("dim", "the project's own skill wins")}`);
+	if (e.practices.length === 0 && e.skippedPractices.length === 0) lines.push(style("dim", "  off"));
+	lines.push("", `Appended to Claude Code's system prompt: ${approx(e.appendedTokens)}`);
+	return lines;
+};
+const explain = defineCommand({
+	meta: {
+		name: "explain",
+		description: "Show what one node's session loads, layer by layer"
+	},
+	args: {
+		workflow: {
+			type: "positional",
+			description: "A workflow file, the name of one in the project's workflows (.ork/workflows/), or one of Ork's own (ork:feedback-apply)",
+			required: true
+		},
+		node: {
+			type: "positional",
+			description: "Node id",
+			required: true
+		},
+		json: {
+			type: "boolean",
+			description: "Print JSON",
+			default: false
+		}
+	},
+	run: ({ args }) => {
+		const cwd = process.cwd();
+		if (refusedBuiltin([args.workflow], cwd)) return;
+		const result = explainNode(workflowArg(args.workflow, cwd).file, args.node, cwd);
+		if (!result.ok) {
+			for (const line of result.lines) process.stderr.write(`${line}\n`);
+			process.exitCode = 1;
+			return;
+		}
+		if (args.json) write(JSON.stringify(result.explanation, void 0, 2));
+		else for (const line of formatExplanation(result.explanation)) write(line);
+	}
+});
+const context = defineCommand({
+	meta: {
+		name: "context",
+		description: "Inspect the context Ork compiles for each node"
+	},
+	subCommands: { explain }
+});
+export { explainNode as n, context as t };

package/dist/{find-CjsNYAAf.mjs → find-BYLlszqj.mjs}

@@ -1,4 +1,4 @@
-import { Un as placeFor } from "./src-BeR6f70A.mjs";
+import { Dr as placeFor } from "./src-Dr_fTSu-.mjs";
 import { randomUUID } from "node:crypto";
 // ../core/src/remote/find.ts
 /**