@oisincoveney/pipeline 3.24.2 → 4.0.0

package/dist/run-control/detach.js

@@ -1,79 +1,73 @@
-import { Effect } from "effect";
 import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
+import { Effect, Option } from "effect";
 import { spawn } from "node:child_process";
 //#region src/run-control/detach.ts
-function startDetachedRunController(input) {
-	return Effect.runPromise(startDetachedRunControllerEffect(input));
-}
-function startDetachedRunControllerEffect(input) {
-	return Effect.gen(function* () {
-		const command = process.execPath;
-		const args = yield* controllerArgsEffect(input);
-		const child = yield* Effect.sync(() => spawn(command, args, {
-			cwd: input.workspaceRoot,
-			detached: true,
-			env: {
-				...process.env,
-				PIPELINE_TARGET_PATH: input.workspaceRoot
-			},
-			stdio: "ignore"
-		}));
-		if (!child.pid) return yield* Effect.fail(/* @__PURE__ */ new Error("Detached run controller did not expose a process id."));
-		yield* waitForControllerSpawnEffect(child);
-		yield* Effect.sync(() => child.unref());
-		return {
-			argv: [command, ...args],
-			pid: child.pid,
-			startedAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
+const optionalOption = (name, value) => Option.match(value, {
+	onNone: () => [],
+	onSome: (definedValue) => [name, definedValue]
+});
+const pathExistsEffect = (path) => Effect.sync(() => existsSync(path));
+const cliEntrypointPathEffect = () => Effect.gen(function* effectBody() {
+	const envEntrypoint = process.env.MOKA_CLI_ENTRYPOINT;
+	if (envEntrypoint !== void 0 && envEntrypoint.length > 0) return envEntrypoint;
+	const moduleDir = import.meta.dirname;
+	const compiledEntrypoint = join(moduleDir, "..", "index.js");
+	if (yield* pathExistsEffect(compiledEntrypoint)) return compiledEntrypoint;
+	const sourceEntrypoint = join(moduleDir, "..", "index.ts");
+	if (yield* pathExistsEffect(sourceEntrypoint)) return sourceEntrypoint;
+	return process.argv[1] ?? compiledEntrypoint;
+});
+const controllerArgsEffect = (input) => Effect.gen(function* effectBody() {
+	return [
+		yield* cliEntrypointPathEffect(),
+		"run-controller",
+		"--run-id",
+		input.runId,
+		...optionalOption("--schedule", Option.fromNullishOr(input.schedule)),
+		...optionalOption("--entrypoint", Option.fromNullishOr(input.entrypoint)),
+		...optionalOption("--workflow", Option.fromNullishOr(input.workflow)),
+		"--",
+		input.task
+	];
+});
+const waitForControllerSpawnEffect = (child) => Effect.callback((resume) => {
+	const onSpawn = () => {
+		resume(Effect.void);
+	};
+	const onError = (error) => {
+		resume(Effect.fail(error));
+	};
+	child.once("spawn", onSpawn);
+	child.once("error", onError);
+	return Effect.sync(() => {
+		child.off("spawn", onSpawn);
+		child.off("error", onError);
 	});
-}
-function controllerArgsEffect(input) {
-	return Effect.gen(function* () {
-		return [
-			yield* cliEntrypointPathEffect(),
-			"run-controller",
-			"--run-id",
-			input.runId,
-			...optionalOption("--schedule", input.schedule),
-			...optionalOption("--entrypoint", input.entrypoint),
-			...optionalOption("--workflow", input.workflow),
-			"--",
-			input.task
-		];
+});
+const startDetachedRunControllerEffect = (input) => Effect.gen(function* effectBody() {
+	const command = process.execPath;
+	const args = yield* controllerArgsEffect(input);
+	const child = yield* Effect.sync(() => spawn(command, args, {
+		cwd: input.workspaceRoot,
+		detached: true,
+		env: {
+			...process.env,
+			PIPELINE_TARGET_PATH: input.workspaceRoot
+		},
+		stdio: "ignore"
+	}));
+	if (child.pid === void 0 || child.pid === 0) return yield* Effect.fail(/* @__PURE__ */ new Error("Detached run controller did not expose a process id."));
+	yield* waitForControllerSpawnEffect(child);
+	yield* Effect.sync(() => {
+		child.unref();
 	});
-}
-function optionalOption(name, value) {
-	return value ? [name, value] : [];
-}
-function cliEntrypointPathEffect() {
-	return Effect.gen(function* () {
-		const envEntrypoint = process.env.MOKA_CLI_ENTRYPOINT;
-		if (envEntrypoint) return envEntrypoint;
-		const moduleDir = dirname(fileURLToPath(import.meta.url));
-		const compiledEntrypoint = join(moduleDir, "..", "index.js");
-		if (yield* pathExistsEffect(compiledEntrypoint)) return compiledEntrypoint;
-		const sourceEntrypoint = join(moduleDir, "..", "index.ts");
-		if (yield* pathExistsEffect(sourceEntrypoint)) return sourceEntrypoint;
-		return process.argv[1] ?? compiledEntrypoint;
-	});
-}
-function pathExistsEffect(path) {
-	return Effect.sync(() => existsSync(path));
-}
-function waitForControllerSpawnEffect(child) {
-	return Effect.callback((resume) => {
-		const onSpawn = () => resume(Effect.void);
-		const onError = (error) => resume(Effect.fail(error));
-		child.once("spawn", onSpawn);
-		child.once("error", onError);
-		return Effect.sync(() => {
-			child.off("spawn", onSpawn);
-			child.off("error", onError);
-		});
-	});
-}
+	return {
+		argv: [command, ...args],
+		pid: child.pid,
+		startedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+});
+const startDetachedRunController = async (input) => await Effect.runPromise(startDetachedRunControllerEffect(input));
 //#endregion
 export { startDetachedRunController, startDetachedRunControllerEffect };

package/dist/run-control/file-errors.js

@@ -1,6 +1,4 @@
 //#region src/run-control/file-errors.ts
-function isNotFound(error) {
-	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
+const isNotFound = (error) => typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 //#endregion
 export { isNotFound };

package/dist/run-control/logical-segment.js

@@ -1,9 +1,9 @@
 import "effect";
 //#region src/run-control/logical-segment.ts
-const LOGICAL_SEGMENT_PATTERN = /^(?!\.{1,2}$)(?!.*[\\/]).+$/;
-function parseLogicalSegment(label, value) {
+const LOGICAL_SEGMENT_PATTERN = /^(?!\.{1,2}$)(?!.*[\\/]).+$/u;
+const parseLogicalSegment = (label, value) => {
 	if (!LOGICAL_SEGMENT_PATTERN.test(value)) throw new Error(`${label} must be a non-empty logical identifier.`);
 	return value;
-}
+};
 //#endregion
 export { parseLogicalSegment };

package/dist/run-control/next-node.js

@@ -5,7 +5,7 @@ import { compileScheduleArtifact, parseScheduleArtifact } from "../planning/gene
 import { computeReadyNodeIds } from "../runtime/scheduler.js";
 import { buildEnvelopeForNode, collectStoredResults } from "../runtime/step/step-node.js";
 import { resolveDurableStore } from "../runtime/durable-store/acquisition.js";
-import { Effect } from "effect";
+import { Effect, Option } from "effect";
 //#region src/run-control/next-node.ts
 /**
 * PIPE-91.6: compute and return the {@link NextNodeEnvelope} for the first
@@ -20,99 +20,88 @@ import { Effect } from "effect";
 * meaningful output to hand the next executor. Pure function: store reads are
 * injected via `input.store`.
 */
-function buildNextNodeEnvelope(input) {
+const buildNextNodeEnvelopeOption = (input) => {
 	const nodeId = computeReadyNodeIds({
 		completed: collectStoredResults(input),
 		nodes: input.nodes
 	})[0];
-	if (nodeId === void 0) return;
-	return buildEnvelopeForNode(input, nodeId);
-}
-function buildNextNodeEnvelopeFromRunStore(input) {
-	return Effect.gen(function* () {
-		const { nodeMetadata, nodes } = yield* scheduleNodesFromRunStore(input);
-		return buildNextNodeEnvelope({
-			nodeMetadata,
+	return Option.flatMap(Option.fromUndefinedOr(nodeId), (value) => Option.fromUndefinedOr(buildEnvelopeForNode(input, value)));
+};
+const buildNextNodeEnvelope = (input) => Option.getOrUndefined(buildNextNodeEnvelopeOption(input));
+const readPersistedScheduleEffect = (store, runId) => Effect.gen(function* effectBody() {
+	const manifest = yield* store.readRun({ runId });
+	if (manifest === void 0) return yield* Effect.fail(/* @__PURE__ */ new Error(`Run ${runId} does not exist in the Moka DB.`));
+	if (manifest.schedule === void 0 || manifest.schedule.length === 0) return yield* Effect.fail(/* @__PURE__ */ new Error(`Run ${runId} has no persisted schedule. moka next node reads schedules from the Moka DB; start the run with moka run so manifest.schedule is persisted.`));
+	return manifest.schedule;
+});
+const scheduleNodesFromRunStore = (input) => Effect.gen(function* effectBody() {
+	const scheduleRaw = yield* readPersistedScheduleEffect(input.runControlStore, input.runId);
+	const { plan } = yield* Effect.try({
+		catch: (error) => error,
+		try: () => compileScheduleArtifact(input.config, parseScheduleArtifact(scheduleRaw, `persisted schedule for ${input.runId}`), input.worktreePath)
+	});
+	const nodes = plan.topologicalOrder;
+	return {
+		nodeMetadata: new Map(plan.topologicalOrder.map((node) => [node.id, {
+			criteria: node.taskContext?.acceptanceCriteria ?? [],
+			prompt: node.taskContext?.description ?? node.id
+		}])),
+		nodes
+	};
+});
+const buildNextNodeEnvelopeFromRunStore = (input) => Effect.gen(function* effectBody() {
+	const { nodeMetadata, nodes } = yield* scheduleNodesFromRunStore(input);
+	return buildNextNodeEnvelope({
+		nodeMetadata,
+		nodes,
+		runId: input.runId,
+		store: input.durableStore
+	});
+});
+const readyNodeIdsFromRunStore = (input) => Effect.gen(function* effectBody() {
+	const { nodes } = yield* scheduleNodesFromRunStore(input);
+	return computeReadyNodeIds({
+		completed: collectStoredResults({
+			nodeMetadata: /* @__PURE__ */ new Map(),
 			nodes,
 			runId: input.runId,
 			store: input.durableStore
-		});
+		}),
+		nodes
 	});
-}
-function readyNodeIdsFromRunStore(input) {
-	return Effect.gen(function* () {
-		const { nodes } = yield* scheduleNodesFromRunStore(input);
-		return computeReadyNodeIds({
-			completed: collectStoredResults({
-				nodeMetadata: /* @__PURE__ */ new Map(),
-				nodes,
-				runId: input.runId,
-				store: input.durableStore
-			}),
-			nodes
-		});
+});
+const printNextNodeEnvelopeScoped = (runId) => Effect.gen(function* effectBody() {
+	const cwd = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
+	const config = yield* Effect.try({
+		catch: (error) => error,
+		try: () => loadPipelineConfig(cwd)
 	});
-}
-function scheduleNodesFromRunStore(input) {
-	return Effect.gen(function* () {
-		const scheduleRaw = yield* readPersistedScheduleEffect(input.runControlStore, input.runId);
-		const plan = (yield* Effect.try({
-			catch: (error) => error,
-			try: () => compileScheduleArtifact(input.config, parseScheduleArtifact(scheduleRaw, `persisted schedule for ${input.runId}`), input.worktreePath)
-		})).plan;
-		const nodes = plan.topologicalOrder;
-		return {
-			nodeMetadata: new Map(plan.topologicalOrder.map((node) => [node.id, {
-				criteria: node.taskContext?.acceptanceCriteria ?? [],
-				prompt: node.taskContext?.description ?? node.id
-			}])),
-			nodes
-		};
+	const dbUrl = loadMokaDbUrl();
+	const runControlStore = yield* resolveRunControlStore(dbUrl, cwd);
+	const durableStore = yield* resolveDurableStore(dbUrl, runId);
+	const envelope = yield* buildNextNodeEnvelopeFromRunStore({
+		config,
+		durableStore,
+		runControlStore,
+		runId,
+		worktreePath: cwd
 	});
-}
-function readPersistedScheduleEffect(store, runId) {
-	return Effect.gen(function* () {
-		const manifest = yield* store.readRun({ runId });
-		if (manifest === void 0) return yield* Effect.fail(/* @__PURE__ */ new Error(`Run ${runId} does not exist in the Moka DB.`));
-		if (!manifest.schedule) return yield* Effect.fail(/* @__PURE__ */ new Error(`Run ${runId} has no persisted schedule. moka next node reads schedules from the Moka DB; start the run with moka run so manifest.schedule is persisted.`));
-		return manifest.schedule;
-	});
-}
+	if (envelope === void 0) {
+		process.stdout.write("No ready nodes — run is complete or all remaining nodes are blocked.\n");
+		process.exitCode = 1;
+		return;
+	}
+	process.stdout.write(`${JSON.stringify(envelope, null, 2)}\n`);
+});
+const printNextNodeEnvelopeEffect = (runId) => Effect.scoped(printNextNodeEnvelopeScoped(runId));
 /**
 * Register `moka next node <run-id>` under the `next` command group. The
 * schedule is read from the run-control manifest in the Moka DB by run id.
 */
-function registerNextNodeSubcommand(nextCommand) {
+const registerNextNodeSubcommand = (nextCommand) => {
 	nextCommand.command("node").description("Emit the next ready node envelope from a persisted run without executing it").argument("<run-id>", "the run id to query").showHelpAfterError("Remove --schedule-file; moka next node reads schedules from the Moka DB by run id.").action(async (runId) => {
 		await Effect.runPromise(printNextNodeEnvelopeEffect(runId));
 	});
-}
-function printNextNodeEnvelopeEffect(runId) {
-	return Effect.scoped(printNextNodeEnvelopeScoped(runId));
-}
-function printNextNodeEnvelopeScoped(runId) {
-	return Effect.gen(function* () {
-		const cwd = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
-		const config = yield* Effect.try({
-			catch: (error) => error,
-			try: () => loadPipelineConfig(cwd)
-		});
-		const dbUrl = loadMokaDbUrl();
-		const runControlStore = yield* resolveRunControlStore(dbUrl, cwd);
-		const envelope = yield* buildNextNodeEnvelopeFromRunStore({
-			config,
-			durableStore: yield* resolveDurableStore(dbUrl, runId),
-			runControlStore,
-			runId,
-			worktreePath: cwd
-		});
-		if (envelope === void 0) {
-			process.stdout.write("No ready nodes — run is complete or all remaining nodes are blocked.\n");
-			process.exitCode = 1;
-			return;
-		}
-		process.stdout.write(`${JSON.stringify(envelope, null, 2)}\n`);
-	});
-}
+};
 //#endregion
 export { buildNextNodeEnvelope, buildNextNodeEnvelopeFromRunStore, readPersistedScheduleEffect, readyNodeIdsFromRunStore, registerNextNodeSubcommand };