@oisincoveney/pipeline 3.24.2 → 4.0.0

package/dist/run-control/supervisor.js

@@ -1,9 +1,9 @@
 import { parseRunControlStaleDetection } from "./contracts.js";
 import { createSerializedWriteQueue } from "../serialized-write-queue.js";
 import { createRunStoreRuntimeReporter } from "./runtime-reporter.js";
-import { Effect } from "effect";
+import { Effect, Option } from "effect";
 //#region src/run-control/supervisor.ts
-const RUNNING_NODE_EVENT_TYPES = /* @__PURE__ */ new Set([
+const isRunningNodeEvent = (event) => [
 	"agent.start",
 	"artifact.check.start",
 	"gate.start",
@@ -14,20 +14,39 @@ const RUNNING_NODE_EVENT_TYPES = /* @__PURE__ */ new Set([
 	"node.start",
 	"output.repair",
 	"runtime.observability"
-]);
-function createRunControlSupervisor(input) {
-	return Effect.runSync(createRunControlSupervisorEffect(input));
-}
-function createRunControlSupervisorEffect(input) {
-	return Effect.sync(() => createRunControlSupervisorRuntime(input));
-}
-function createRunControlSupervisorRuntime(input) {
+].includes(event.type);
+const CLEAR_NODE_ACTIVITY = [
+	(event) => event.type === "node.finish",
+	(event) => event.type === "agent.finish" && event.exitCode !== 0,
+	(event) => (event.type === "artifact.check.finish" || event.type === "hook.finish") && event.required && !event.passed,
+	(event) => event.type === "gate.finish" && !event.passed
+];
+const MARK_NODE_RUNNING = [
+	isRunningNodeEvent,
+	(event) => event.type === "agent.finish" && event.exitCode === 0,
+	(event) => (event.type === "artifact.check.finish" || event.type === "hook.finish") && (event.passed || !event.required),
+	(event) => event.type === "gate.finish" && event.passed
+];
+const timestamp = (now) => now().toISOString();
+const nodeIdFromEvent = (event) => {
+	if (!("nodeId" in event)) return Option.none();
+	return Option.fromUndefinedOr(event.nodeId);
+};
+const shouldClearNodeActivity = (event) => CLEAR_NODE_ACTIVITY.some((predicate) => predicate(event));
+const shouldMarkNodeRunning = (event) => MARK_NODE_RUNNING.some((predicate) => predicate(event));
+const scheduleStaleTimerEffect = (input) => Effect.sync(() => {
+	if (input.activity.staleTimer) clearTimeout(input.activity.staleTimer);
+	input.activity.staleTimer = setTimeout(() => {
+		input.onTimer(input.nodeId);
+	}, input.delayMs);
+});
+const createRunControlSupervisorRuntime = (input) => {
 	const now = input.now ?? (() => /* @__PURE__ */ new Date());
 	const staleDetection = parseRunControlStaleDetection({
 		heartbeatIntervalMs: input.heartbeatIntervalMs ?? 3e4,
 		nodeStaleAfterMs: input.nodeStaleAfterMs ?? 12e4
 	});
-	const store = input.store;
+	const { store } = input;
 	const bridge = createRunStoreRuntimeReporter({
 		now,
 		reporter: input.reporter,
@@ -37,17 +56,21 @@ function createRunControlSupervisorRuntime(input) {
 	});
 	const nodeActivity = /* @__PURE__ */ new Map();
 	const controlWrites = createSerializedWriteQueue();
-	let heartbeatTimer;
+	let heartbeatTimer = Option.none();
 	let runActive = false;
 	let stopped = false;
 	const flushControlWritesEffect = () => Effect.tryPromise({
 		catch: (error) => error,
-		try: () => controlWrites.flush()
+		try: async () => {
+			await controlWrites.flush();
+		}
 	});
 	const enqueueControlWriteEffect = (write) => Effect.sync(() => {
-		controlWrites.enqueue(() => Effect.runPromise(bridge.flushEffect().pipe(Effect.andThen(write))));
+		controlWrites.enqueue(async () => {
+			await Effect.runPromise(bridge.flushEffect().pipe(Effect.andThen(write)));
+		});
 	});
-	const enqueueHeartbeatEffect = () => Effect.gen(function* () {
+	const enqueueHeartbeatEffect = () => Effect.gen(function* enqueueHeartbeatProgram() {
 		if (!(runActive && !stopped)) return;
 		const at = timestamp(now);
 		yield* enqueueControlWriteEffect(store.recordEvent({
@@ -62,16 +85,20 @@ function createRunControlSupervisorRuntime(input) {
 	const enqueueHeartbeat = () => {
 		Effect.runSync(enqueueHeartbeatEffect());
 	};
-	const scheduleStaleTimerEffect = (nodeId, activity, delayMs = staleDetection.nodeStaleAfterMs) => Effect.sync(() => {
-		if (activity.staleTimer) clearTimeout(activity.staleTimer);
-		activity.staleTimer = setTimeout(() => markNodeStalled(nodeId), delayMs);
-	});
-	const markNodeStalledEffect = (nodeId) => Effect.gen(function* () {
+	const markNodeStalledEffect = (nodeId) => Effect.gen(function* effectBody() {
 		const activity = nodeActivity.get(nodeId);
 		if (!(activity && runActive && !stopped && activity.status === "running")) return;
 		const elapsedMs = now().getTime() - activity.lastActivityMs;
 		if (elapsedMs < staleDetection.nodeStaleAfterMs) {
-			yield* scheduleStaleTimerEffect(nodeId, activity, staleDetection.nodeStaleAfterMs - elapsedMs);
+			const delayMs = staleDetection.nodeStaleAfterMs - elapsedMs;
+			yield* scheduleStaleTimerEffect({
+				activity,
+				delayMs,
+				nodeId,
+				onTimer: (stalledNodeId) => {
+					Effect.runSync(markNodeStalledEffect(stalledNodeId));
+				}
+			});
 			return;
 		}
 		activity.status = "stalled";
@@ -84,10 +111,7 @@ function createRunControlSupervisorRuntime(input) {
 			status: "stalled"
 		}));
 	});
-	const markNodeStalled = (nodeId) => {
-		Effect.runSync(markNodeStalledEffect(nodeId));
-	};
-	const markNodeRunningEffect = (nodeId) => Effect.gen(function* () {
+	const markNodeRunningEffect = (nodeId) => Effect.gen(function* markNodeRunningProgram() {
 		if (!(runActive && !stopped)) return;
 		const previous = nodeActivity.get(nodeId);
 		const wasStalled = previous?.status === "stalled";
@@ -97,7 +121,14 @@ function createRunControlSupervisorRuntime(input) {
 			status: "running"
 		};
 		nodeActivity.set(nodeId, activity);
-		yield* scheduleStaleTimerEffect(nodeId, activity);
+		yield* scheduleStaleTimerEffect({
+			activity,
+			delayMs: staleDetection.nodeStaleAfterMs,
+			nodeId,
+			onTimer: (stalledNodeId) => {
+				Effect.runSync(markNodeStalledEffect(stalledNodeId));
+			}
+		});
 		if (wasStalled) {
 			const at = timestamp(now);
 			yield* enqueueControlWriteEffect(store.updateNodeStatus({
@@ -113,8 +144,8 @@ function createRunControlSupervisorRuntime(input) {
 		if (activity?.staleTimer) clearTimeout(activity.staleTimer);
 		nodeActivity.delete(nodeId);
 	});
-	const clearAllNodesEffect = () => Effect.forEach([...nodeActivity.keys()], clearNodeEffect).pipe(Effect.asVoid);
-	const observeRuntimeEventEffect = (event) => Effect.gen(function* () {
+	const clearAllNodesEffect = () => Effect.forEach([...nodeActivity.keys()], clearNodeEffect, { concurrency: 1 }).pipe(Effect.asVoid);
+	const observeRuntimeEventEffect = (event) => Effect.gen(function* observeRuntimeEventProgram() {
 		if (event.type === "workflow.start") {
 			runActive = true;
 			return;
@@ -125,33 +156,35 @@ function createRunControlSupervisorRuntime(input) {
 			return;
 		}
 		const nodeId = nodeIdFromEvent(event);
-		if (!nodeId) return;
+		if (Option.isNone(nodeId) || nodeId.value.length === 0) return;
 		if (shouldClearNodeActivity(event)) {
-			yield* clearNodeEffect(nodeId);
+			yield* clearNodeEffect(nodeId.value);
 			return;
 		}
-		if (shouldMarkNodeRunning(event)) yield* markNodeRunningEffect(nodeId);
+		if (shouldMarkNodeRunning(event)) yield* markNodeRunningEffect(nodeId.value);
 	});
 	const startEffect = () => Effect.sync(() => {
-		if (heartbeatTimer || stopped) return;
-		heartbeatTimer = setInterval(enqueueHeartbeat, staleDetection.heartbeatIntervalMs);
+		if (Option.isSome(heartbeatTimer) || stopped) return;
+		heartbeatTimer = Option.some(setInterval(enqueueHeartbeat, staleDetection.heartbeatIntervalMs));
 	});
-	const stopEffect = () => Effect.gen(function* () {
+	const stopEffect = () => Effect.gen(function* stopProgram() {
 		stopped = true;
-		if (heartbeatTimer) {
-			clearInterval(heartbeatTimer);
-			heartbeatTimer = void 0;
+		if (Option.isSome(heartbeatTimer)) {
+			clearInterval(heartbeatTimer.value);
+			heartbeatTimer = Option.none();
 		}
 		yield* clearAllNodesEffect();
 		yield* bridge.flushEffect();
 		yield* flushControlWritesEffect();
 	});
-	const flushEffect = () => Effect.gen(function* () {
+	const flushEffect = () => Effect.gen(function* flushProgram() {
 		yield* bridge.flushEffect();
 		yield* flushControlWritesEffect();
 	});
 	return {
-		flush: () => Effect.runPromise(flushEffect()),
+		flush: async () => {
+			await Effect.runPromise(flushEffect());
+		},
 		flushEffect,
 		reporter(event) {
 			bridge.reporter(event);
@@ -161,36 +194,13 @@ function createRunControlSupervisorRuntime(input) {
 			Effect.runSync(startEffect());
 		},
 		startEffect,
-		stop: () => Effect.runPromise(stopEffect()),
+		stop: async () => {
+			await Effect.runPromise(stopEffect());
+		},
 		stopEffect
 	};
-}
-function timestamp(now) {
-	return now().toISOString();
-}
-function nodeIdFromEvent(event) {
-	if (!("nodeId" in event)) return;
-	return event.nodeId;
-}
-function shouldClearNodeActivity(event) {
-	switch (event.type) {
-		case "node.finish": return true;
-		case "agent.finish": return event.exitCode !== 0;
-		case "artifact.check.finish":
-		case "hook.finish": return event.required && !event.passed;
-		case "gate.finish": return !event.passed;
-		default: return false;
-	}
-}
-function shouldMarkNodeRunning(event) {
-	if (RUNNING_NODE_EVENT_TYPES.has(event.type)) return true;
-	switch (event.type) {
-		case "agent.finish": return event.exitCode === 0;
-		case "artifact.check.finish":
-		case "hook.finish": return event.passed || !event.required;
-		case "gate.finish": return event.passed;
-		default: return false;
-	}
-}
+};
+const createRunControlSupervisorEffect = (input) => Effect.sync(() => createRunControlSupervisorRuntime(input));
+const createRunControlSupervisor = (input) => Effect.runSync(createRunControlSupervisorEffect(input));
 //#endregion
 export { createRunControlSupervisor, createRunControlSupervisorEffect };

package/dist/run-control/workspace.js

@@ -12,12 +12,12 @@ const GITIGNORE_CONTENT = "*\n";
 * Idempotent: creates the file only if it does not already exist; never
 * overwrites an existing `.pipeline/.gitignore`.
 */
-function ensurePipelineWorkspaceIgnore(worktreePath) {
+const ensurePipelineWorkspaceIgnore = (worktreePath) => {
 	const pipelineDir = join(worktreePath, PIPELINE_DIR);
 	const gitignorePath = join(worktreePath, GITIGNORE_PATH);
 	if (existsSync(gitignorePath)) return;
 	mkdirSync(pipelineDir, { recursive: true });
 	writeFileSync(gitignorePath, GITIGNORE_CONTENT);
-}
+};
 //#endregion
 export { ensurePipelineWorkspaceIgnore };