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

package/dist/{run-D8divGCs.mjs → run-CiPsW9Kf.mjs}

@@ -1,4 +1,4 @@
-import { dn as git, fn as gitOk } from "./src-tsuZRu0H.mjs";
+import { Jt as gitOk, qt as git } from "./src-Dr_fTSu-.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";

package/dist/{send-CXv8bx0i.mjs → send-CnNNW-ot.mjs}

@@ -1,6 +1,6 @@
-import { U as openStore, at as scriptRefusal, it as TOO_LONG, ot as sendFromScript } from "./src-tsuZRu0H.mjs";
+import { U as openStore, at as scriptRefusal, it as TOO_LONG, ot as sendFromScript } from "./src-Dr_fTSu-.mjs";
 import { l as writeErr } from "./output-B1kwo0YU.mjs";
-import { u as inheritedScrubber } from "./src-C7z_6fhn.mjs";
+import { u as inheritedScrubber } from "./src-DcrhgipG.mjs";
 import { defineCommand } from "citty";
 // src/commands/send.ts
 /**

package/dist/{src-njdtejgZ.mjs → src-B9zWIVqo.mjs}

@@ -1,4 +1,5 @@
-import { $n as maskSecrets, $t as countedTokens, An as END_KINDS, Mn as FEEDBACK_KINDS, Nn as FEEDBACK_SEVERITIES, On as outcomeEnd, Pn as FEEDBACK_TARGETS, Pt as parseReport, Zn as MASK, ii as AGENT_DRIVERS, jn as endFor, ln as lowerChild, un as startAt } from "./src-tsuZRu0H.mjs";
+import { Bn as outcomeEnd, Et as parseReport, Gn as FEEDBACK_SEVERITIES, Gt as programFound, Hn as END_KINDS, Kn as FEEDBACK_TARGETS, Kt as startAt, Nn as countedTokens, Un as endFor, Wn as FEEDBACK_KINDS, Wt as lowerChild, _i as AGENT_DRIVERS, fr as maskSecrets, ur as MASK } from "./src-Dr_fTSu-.mjs";
+import { n as holdGuard, r as orphanGuard } from "./orphan-guard-BFKg8VSd.mjs";
 import path from "node:path";
 import { z } from "zod";
 import { existsSync, linkSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
@@ -8,6 +9,13 @@ import { createInterface } from "node:readline";
 import { execFile, spawn } from "node:child_process";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { createServer } from "node:http";
+// ../core/src/follow-ups/types.ts
+const FOLLOW_UP_KINDS = [
+	"change",
+	"message",
+	"task",
+	"check"
+];
 // ../runtime/src/hold.ts
 /**
 * Waits at a tool call while `hold` is held: "go" once it is released within
@@ -543,13 +551,62 @@ const driverFailure = (message, kind, scope) => ({
 		errors: [message]
 	}
 });
+// ../runtime/src/leg-spawn.ts
+/**
+* @file Starting one process (leg) of a session: at the project's priority, and
+*   off Windows in its own process group beside the orphan guard, so it and
+*   what it started end with `ork`, whatever ends `ork`. The process's pid, and
+*   the SIGINT that stops it, stay the driver's own.
+*/
+/** The fd of the orphan guard's pipe from `ork`. */
+const WATCH_FD = 3;
+/**
+* Starts the orphan guard, then becomes the driver. The pipe is closed by a
+* bare `exec`: macOS's `sh` keeps a copy of a descriptor an `exec` command
+* closes, which the driver and its leftovers would then inherit.
+*/
+const GUARDED = `${orphanGuard(WATCH_FD)}exec ${String(WATCH_FD)}<&-; exec "$0" "$@"`;
+const piped = (child) => child.stdin !== null && child.stdout !== null && child.stderr !== null;
+/**
+* Spawns the leg's process. A program that isn't there is spawned bare, so it
+* fails as spawn's ENOENT; the guard is released once the driver exits, so a
+* session that ends normally leaves its leftovers alone.
+*/
+const spawnLeg = (start) => {
+	const [bin, args] = startAt(start.priority, start.bin, start.args, start.env);
+	const guarded = process.platform !== "win32" && programFound(start.bin, start.env);
+	const child = spawn(guarded ? "/bin/sh" : bin, guarded ? [
+		"-c",
+		GUARDED,
+		bin,
+		...args
+	] : args, {
+		cwd: start.cwd,
+		detached: guarded,
+		env: { ...start.env },
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe",
+			guarded ? "pipe" : "ignore"
+		]
+	});
+	if (!piped(child)) throw new Error(`${start.bin} was started without pipes`);
+	if (guarded) {
+		const release = holdGuard(child.stdio[WATCH_FD]);
+		child.once("exit", release);
+	}
+	return child;
+};
 // ../runtime/src/session-leg.ts
 /**
 * @file One process (leg) of a session the runner drives: it writes the queued
 *   stdin lines, yields the adapter's decoded events, and says how it ended. A
 *   session is one leg, or several when a paused node's tool call was deferred
 *   or a message waits for a tool that takes none mid-session; a resumed leg
-*   carries what the legs before it spent, and its start is not news.
+*   carries what the legs before it spent, and its start is not news. Off
+*   Windows the process ends with `ork`, whatever ends `ork` (the orphan
+*   guard).
 */
 const REASON_LIMIT = 500;
 /** Marks a session's start with the driver that runs it. */
@@ -638,16 +695,7 @@ const failureReason = (name, stderr, code) => {
 };
 /** Runs one process of a session, yielding its events; returns how it ended. */
 const runLeg = async function* (input) {
-	const [bin, args] = startAt(input.priority, input.bin, input.args, input.env);
-	const child = spawn(bin, args, {
-		cwd: input.cwd,
-		env: { ...input.env },
-		stdio: [
-			"pipe",
-			"pipe",
-			"pipe"
-		]
-	});
+	const child = spawnLeg(input);
 	lowerChild(input.priority, child.pid);
 	const exited = new Promise((resolve) => {
 		child.on("close", (code, signal) => {
@@ -884,6 +932,74 @@ const feedbackTool = defineTool({
 		return Promise.resolve(text(sent.ok ? "Recorded. Thank you; carry on with your task." : `Not recorded: ${sent.error}.`));
 	}
 });
+// ../runtime/src/tools/follow-up.ts
+/**
+* @file `follow_up`: a session's way to leave work the change leaves for later
+*   (a change for a later run, a note for another project, a message a person
+*   must send, a task or a check for the maintainer). Ork keeps it where the
+*   project's `followUps` rule says, merges duplicates, caps it per session,
+*   and never sends or runs anything on its own.
+*/
+const isFor = (value) => /^(?:agent|me|project:\S.*|person:\S.*)$/u.test(value);
+const isDue = (value) => /^(?:now|after-merge|after-deploy|\d{4}-\d{2}-\d{2})$/u.test(value);
+const followUpTool = defineTool({
+	name: "follow_up",
+	description: "Leave work this change leaves for later and that is not yours to do now: a change for a later run (for: agent), something for another registered project (for: project:<name>), a message a person must get (for: person:<name>, kind: message, with a draft), or a task or check for the maintainer (for: me, with steps). Ork keeps it, merges duplicates, and sends or runs nothing itself. Not for problems with Ork or the workflow (use feedback), nor for what you can finish now.",
+	shape: {
+		title: z.string().min(1).max(200).describe("One line."),
+		body: z.string().max(4e3).optional().describe("What and why, briefly."),
+		for: z.string().refine(isFor, "agent, me, project:<name> or person:<name>").describe("Who acts: agent, me, project:<name> or person:<name>."),
+		kind: z.enum(FOLLOW_UP_KINDS),
+		due: z.string().refine(isDue, "now, after-merge, after-deploy or YYYY-MM-DD").describe("now, after-merge, after-deploy, or a YYYY-MM-DD date."),
+		where: z.array(z.string()).max(20).optional().describe("Files it is about, relative to the project root."),
+		ref: z.string().min(1).optional().describe("The pull request or branch an after-merge follow-up waits on, when you know it."),
+		draft: z.strictObject({
+			to: z.string().min(1),
+			channel: z.string().optional().describe("github (to: an issue or PR URL), email, slack… A hint for the maintainer."),
+			text: z.string().min(1).max(4e3)
+		}).optional().describe("For a message: what the maintainer will send."),
+		steps: z.array(z.strictObject({
+			text: z.string().min(1),
+			command: z.string().optional().describe("Shown to the maintainer to copy; Ork never runs it.")
+		})).max(20).optional().describe("For a task or check: what to do, in order.")
+	},
+	available: ({ ports }) => ports.followUps !== void 0,
+	run: async ({ ports }, args) => {
+		const port = ports.followUps;
+		if (port === void 0) return text("No follow-ups here.");
+		if (!isFor(args.for) || !isDue(args.due)) return text("Not kept.");
+		const input = {
+			title: args.title,
+			for: args.for,
+			kind: args.kind,
+			due: args.due,
+			...args.body === void 0 ? {} : { body: args.body },
+			...args.where === void 0 ? {} : { where: args.where },
+			...args.ref === void 0 ? {} : { ref: args.ref },
+			...args.draft === void 0 ? {} : { draft: {
+				to: args.draft.to,
+				text: args.draft.text,
+				...args.draft.channel === void 0 ? {} : { channel: args.draft.channel }
+			} },
+			...args.steps === void 0 ? {} : { steps: args.steps.map((step) => ({
+				text: step.text,
+				...step.command === void 0 ? {} : { command: step.command }
+			})) }
+		};
+		const result = await port.add(input);
+		if (!result.ok) return {
+			...text(`Not kept: ${result.error}.`),
+			isError: true
+		};
+		const { followUp, merged, note } = result.added;
+		return text([
+			merged ? `Merged into follow-up ${followUp.id}, which was already kept.` : `Kept as follow-up ${followUp.id}.`,
+			...note === void 0 ? [] : [note],
+			...result.relayed === void 0 ? [] : [`Also sent to ${result.relayed.run}/${result.relayed.node}, a live run of that project.`],
+			"Carry on with your task."
+		].join(" "));
+	}
+});
 // ../runtime/src/tools/input.ts
 /**
 * @file `read_input`: what the workflow sent a node back with, whole. A loop's
@@ -1074,6 +1190,7 @@ const ORK_TOOLS = [
 	claimTool,
 	releaseTool,
 	feedbackTool,
+	followUpTool,
 	{
 		name: REPORT_TOOL$1,
 		bind: (context) => context.report === void 0 || checksItsReport(context.driver) ? null : bound(context.report)