@oisincoveney/pipeline 3.24.2 → 4.0.0

package/dist/cli/run-service.js

@@ -11,78 +11,68 @@ import { createRunStoreRuntimeReporter } from "../run-control/runtime-reporter.j
 import { createTerminalRuntimeReporter, formatRuntimeFailure, formatRuntimeResult } from "./format.js";
 import { startDetachedRunController } from "../run-control/detach.js";
 import { createRunControlSupervisor } from "../run-control/supervisor.js";
-import { Effect } from "effect";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
+import { Effect } from "effect";
 //#region src/cli/run-service.ts
-/**
-* Config-driven `execute` entrypoint. Package-owned defaults are the source of
-* truth; repo-local pipeline files are ignored by runtime loading.
-*/
-function execute(description, options = {}) {
+const detachedRunControllerInput = (input) => ({
+	entrypoint: input.prepared.entrypoint,
+	runId: input.runId,
+	...input.prepared.schedule !== void 0 && input.prepared.schedule !== "" ? { schedule: input.prepared.schedule } : {},
+	task: input.task,
+	workflow: input.prepared.workflow,
+	workspaceRoot: input.worktreePath
+});
+const withRunId = (inputs) => ({
+	...inputs,
+	runId: inputs.runId ?? generateRuntimeRunId()
+});
+const runWithFlushedReporter = async (flush, run) => {
 	try {
-		if (!description.trim()) throw new Error("Task description is required");
-		const worktreePath = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
-		return runConfiguredPipeline({
-			entrypoint: options.entrypoint,
-			pipelineRunner: options.pipelineRunner,
-			runControl: options.runControl,
-			runId: options.runId,
-			runStoreMode: options.runStoreMode,
-			schedule: options.schedule,
-			supervised: options.supervised,
-			supervisor: options.supervisor,
-			task: description,
-			workflow: options.workflow,
-			worktreePath
-		});
-	} catch (err) {
-		return Promise.reject(err);
+		return await run();
+	} finally {
+		await flush();
 	}
-}
-function quick(description, options = {}) {
-	return execute(description, {
-		...options,
-		entrypoint: "quick",
-		runControl: {
-			...options.runControl,
-			effort: "quick"
-		}
-	});
-}
-function runLocalResolvedTask(task, execution, runControl) {
-	return execute(task, {
-		entrypoint: execution.entrypoint,
-		runControl,
-		schedule: execution.schedule,
-		supervised: true,
-		workflow: execution.workflow
-	});
-}
-async function runDetachedResolvedTask(task, execution, runControl) {
-	const worktreePath = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
-	const runId = generateRuntimeRunId();
-	await persistDetachedRunController({
-		prepared: await prepareDetachedRun({
-			config: loadPipelineConfig(worktreePath, { allowMissingLintFileReferences: true }),
-			execution,
-			runId,
-			task,
-			worktreePath
-		}),
-		runControl,
-		runId,
-		task,
-		worktreePath
-	});
-	console.log(formatDetachedRunFollowUp(runId));
-}
-function persistDetachedRunController(input) {
-	return Effect.runPromise(withRunControlStoreScoped(input.worktreePath, (store) => Effect.gen(function* () {
+};
+const requireRunId = (runId = "") => {
+	if (runId === "") throw new Error("Run id is required for local run-control persistence.");
+	return runId;
+};
+const DEFAULT_RUN_CONTROL_OPTIONS = {
+	effort: "normal",
+	mode: "write",
+	target: "local"
+};
+const resolvedRunControlOptions = (input = {}) => ({
+	...DEFAULT_RUN_CONTROL_OPTIONS,
+	...input
+});
+const plannedRunStoreNodeIds = (inputs) => {
+	if (inputs.pipelineRunner !== void 0) return [];
+	const workflowId = resolveWorkflowSelection(inputs.config, inputs.workflow, inputs.entrypoint);
+	return flattenNodes(compileWorkflowPlan(inputs.config, workflowId).topologicalOrder, (node) => node.children).map((node) => node.id);
+};
+const detachedRunRecord = (input) => ({
+	...resolvedRunControlOptions(input.runControl),
+	nodeIds: plannedRunStoreNodeIds({
+		config: input.prepared.config,
+		entrypoint: input.prepared.entrypoint,
+		runControl: input.runControl,
+		runId: input.runId,
+		schedule: input.prepared.schedule,
+		task: input.task,
+		workflow: input.prepared.workflow,
+		worktreePath: input.worktreePath
+	}),
+	runId: input.runId,
+	...input.prepared.scheduleArtifact !== void 0 && input.prepared.scheduleArtifact !== "" ? { schedule: input.prepared.scheduleArtifact } : {}
+});
+const persistDetachedRunController = async (input) => {
+	await Effect.runPromise(withRunControlStoreScoped(input.worktreePath, (store) => Effect.gen(function* effectBody() {
 		yield* store.createRun(detachedRunRecord(input));
 		const launch = yield* Effect.tryPromise({
 			catch: (error) => error,
-			try: () => startDetachedRunController(detachedRunControllerInput(input))
+			try: async () => await startDetachedRunController(detachedRunControllerInput(input))
 		});
 		yield* store.updateRunController({
 			controller: {
@@ -95,130 +85,14 @@ function persistDetachedRunController(input) {
 			runId: input.runId
 		});
 	})));
-}
-function detachedRunControllerInput(input) {
-	return {
-		entrypoint: input.prepared.entrypoint,
-		runId: input.runId,
-		...input.prepared.schedule ? { schedule: input.prepared.schedule } : {},
-		task: input.task,
-		workflow: input.prepared.workflow,
-		workspaceRoot: input.worktreePath
-	};
-}
-function detachedRunRecord(input) {
-	return {
-		...resolvedRunControlOptions(input.runControl),
-		nodeIds: plannedRunStoreNodeIds({
-			config: input.prepared.config,
-			entrypoint: input.prepared.entrypoint,
-			runId: input.runId,
-			runControl: input.runControl,
-			schedule: input.prepared.schedule,
-			task: input.task,
-			workflow: input.prepared.workflow,
-			worktreePath: input.worktreePath
-		}),
-		runId: input.runId,
-		...input.prepared.scheduleArtifact ? { schedule: input.prepared.scheduleArtifact } : {}
-	};
-}
-function withRunId(inputs) {
-	return {
-		...inputs,
-		runId: inputs.runId ?? generateRuntimeRunId()
-	};
-}
-async function runConfiguredPipeline(rawInputs) {
-	const inputs = withRunId(rawInputs);
-	const config = loadPipelineConfig(inputs.worktreePath, { allowMissingLintFileReferences: true });
-	if (inputs.schedule) {
-		const scheduleYaml = readFileSync(inputs.schedule, "utf8");
-		const compiled = compileScheduleArtifact(config, parseScheduleArtifact(scheduleYaml, inputs.schedule), inputs.worktreePath);
-		await runAndPrintPipeline({
-			...inputs,
-			config: compiled.config,
-			scheduleArtifact: scheduleYaml,
-			workflow: compiled.workflowId
-		});
-		return;
-	}
-	const scheduledEntrypoint = scheduledEntrypointId(config, inputs.workflow, inputs.entrypoint);
-	if (scheduledEntrypoint) {
-		if (inputs.pipelineRunner) {
-			await runAndPrintPipeline({
-				...inputs,
-				config
-			});
-			return;
-		}
-		const result = await generateScheduleArtifactInMemory({
-			config,
-			entrypointId: scheduledEntrypoint,
-			runId: inputs.runId,
-			task: inputs.task,
-			worktreePath: inputs.worktreePath
-		});
-		console.log("Schedule generated in memory");
-		const scheduleYaml = result.yaml;
-		const compiled = compileScheduleArtifact(config, parseScheduleArtifact(scheduleYaml, "schedule.yaml"), inputs.worktreePath);
-		await runAndPrintPipeline({
-			...inputs,
-			config: compiled.config,
-			scheduleArtifact: scheduleYaml,
-			workflow: compiled.workflowId
-		});
-		return;
-	}
-	await runAndPrintPipeline({
-		...inputs,
-		config
-	});
-}
-async function runAndPrintPipeline(inputs) {
-	await Effect.runPromise(withRunControlStoreScoped(inputs.worktreePath, (store) => Effect.tryPromise({
-		catch: (error) => error,
-		try: () => runAndPrintPipelineWithStore(inputs, store)
-	})));
-}
-async function runAndPrintPipelineWithStore(inputs, store) {
-	const runner = inputs.pipelineRunner ?? runPipelineFromConfig;
-	const runStoreReporter = await createRunStoreReporter(inputs, createTerminalRuntimeReporter(), store);
-	printSupervisedFollowUp(inputs);
-	const result = await runPipelineSafely(inputs, runner, runStoreReporter);
-	console.log(formatRuntimeResult(result));
-	if (result.outcome !== "PASS") throw new Error(formatRuntimeFailureWithFollowUp(result, inputs));
-}
-function printSupervisedFollowUp(inputs) {
-	if (inputs.supervised) console.log(formatSupervisedRunFollowUp(requireRunId(inputs.runId)));
-}
-function runPipelineSafely(inputs, runner, runStoreReporter) {
-	return runWithFlushedReporter(runStoreReporter.flush, () => runner({
-		config: inputs.config,
-		entrypoint: inputs.entrypoint,
-		reporter: runStoreReporter.reporter,
-		runId: inputs.runId,
-		task: inputs.task,
-		workflowId: inputs.workflow,
-		worktreePath: inputs.worktreePath
-	})).catch((error) => {
-		throw runtimeErrorWithFollowUp(error, inputs);
-	});
-}
-async function runWithFlushedReporter(flush, run) {
-	try {
-		return await run();
-	} finally {
-		await flush();
-	}
-}
-async function createLocalRunStoreRuntimeReporter(inputs, reporter, store) {
+};
+const createLocalRunStoreRuntimeReporter = async (inputs, reporter, store) => {
 	const runId = requireRunId(inputs.runId);
 	await Effect.runPromise(store.createRun({
 		...resolvedRunControlOptions(inputs.runControl),
 		nodeIds: plannedRunStoreNodeIds(inputs),
 		runId,
-		...inputs.scheduleArtifact ? { schedule: inputs.scheduleArtifact } : {}
+		...inputs.scheduleArtifact !== void 0 && inputs.scheduleArtifact !== "" ? { schedule: inputs.scheduleArtifact } : {}
 	}));
 	return createRunStoreRuntimeReporter({
 		reporter,
@@ -226,11 +100,11 @@ async function createLocalRunStoreRuntimeReporter(inputs, reporter, store) {
 		store,
 		workspaceRoot: inputs.worktreePath
 	});
-}
-function createRunStoreReporter(inputs, reporter, store) {
+};
+const createRunStoreReporter = (inputs, reporter, store) => {
 	if (inputs.runStoreMode === "reuse") {
 		const runId = requireRunId(inputs.runId);
-		if (inputs.supervisor) {
+		if (inputs.supervisor === true) {
 			const supervisor = createRunControlSupervisor({
 				reporter,
 				runId,
@@ -251,71 +125,167 @@ function createRunStoreReporter(inputs, reporter, store) {
 		});
 	}
 	return createLocalRunStoreRuntimeReporter(inputs, reporter, store);
-}
-function requireRunId(runId) {
-	if (!runId) throw new Error("Run id is required for local run-control persistence.");
-	return runId;
-}
-function resolvedRunControlOptions(input) {
-	return {
-		...DEFAULT_RUN_CONTROL_OPTIONS,
-		...input
-	};
-}
-const DEFAULT_RUN_CONTROL_OPTIONS = {
-	effort: "normal",
-	mode: "write",
-	target: "local"
 };
-function plannedRunStoreNodeIds(inputs) {
-	if (inputs.pipelineRunner) return [];
-	const workflowId = resolveWorkflowSelection(inputs.config, inputs.workflow, inputs.entrypoint);
-	return flattenNodes(compileWorkflowPlan(inputs.config, workflowId).topologicalOrder, (node) => node.children).map((node) => node.id);
-}
-function formatSupervisedRunFollowUp(runId) {
-	return [
-		`Run id: ${runId}`,
-		`Status: moka status ${runId}`,
-		`Logs: moka logs ${runId}`
-	].join("\n");
-}
-function formatDetachedRunFollowUp(runId) {
-	return [
-		`Run id: ${runId}`,
-		`Status: moka status ${runId}`,
-		`Logs: moka logs ${runId}`,
-		`Stop: moka stop ${runId}`
-	].join("\n");
-}
-function formatRuntimeFailureWithFollowUp(result, inputs) {
+const formatSupervisedRunFollowUp = (runId) => [
+	`Run id: ${runId}`,
+	`Status: moka status ${runId}`,
+	`Logs: moka logs ${runId}`
+].join("\n");
+const printSupervisedFollowUp = (inputs) => {
+	if (inputs.supervised === true) console.log(formatSupervisedRunFollowUp(requireRunId(inputs.runId)));
+};
+const formatDetachedRunFollowUp = (runId) => [
+	`Run id: ${runId}`,
+	`Status: moka status ${runId}`,
+	`Logs: moka logs ${runId}`,
+	`Stop: moka stop ${runId}`
+].join("\n");
+const formatRuntimeFailureWithFollowUp = (result, inputs) => {
 	const message = formatRuntimeFailure(result);
-	if (!(inputs.supervised && inputs.runId)) return message;
+	if (!(inputs.supervised === true && inputs.runId !== void 0)) return message;
 	return [
 		message,
 		"",
 		formatSupervisedRunFollowUp(inputs.runId)
 	].join("\n");
-}
-function runtimeErrorWithFollowUp(error, inputs) {
-	if (!(inputs.supervised && inputs.runId)) return error;
+};
+const runtimeErrorWithFollowUp = (error, inputs) => {
+	if (!(inputs.supervised === true && inputs.runId !== void 0)) return error;
 	const message = error instanceof Error ? error.message : String(error);
 	return new Error([
 		message,
 		"",
 		formatSupervisedRunFollowUp(inputs.runId)
 	].join("\n"));
-}
-function scheduledEntrypointId(config, workflowId, entrypointId) {
-	return workflowId ? null : scheduledEntrypointById(config, entrypointId ?? "execute");
-}
-function scheduledEntrypointById(config, id) {
-	const entrypoint = config.entrypoints[id];
-	return entrypoint && "schedule" in entrypoint ? id : null;
-}
-async function prepareDetachedRun(input) {
-	if (input.execution.schedule) {
+};
+const runPipelineSafely = async (inputs, runner, runStoreReporter) => await runWithFlushedReporter(runStoreReporter.flush, async () => await runner({
+	config: inputs.config,
+	entrypoint: inputs.entrypoint,
+	reporter: runStoreReporter.reporter,
+	runId: inputs.runId,
+	task: inputs.task,
+	workflowId: inputs.workflow,
+	worktreePath: inputs.worktreePath
+})).catch((error) => {
+	throw runtimeErrorWithFollowUp(error, inputs);
+});
+const runAndPrintPipelineWithStore = async (inputs, store) => {
+	const runner = inputs.pipelineRunner ?? runPipelineFromConfig;
+	const terminalReporter = createTerminalRuntimeReporter();
+	const runStoreReporter = await createRunStoreReporter(inputs, terminalReporter, store);
+	printSupervisedFollowUp(inputs);
+	const result = await runPipelineSafely(inputs, runner, runStoreReporter);
+	console.log(formatRuntimeResult(result));
+	if (result.outcome !== "PASS") throw new Error(formatRuntimeFailureWithFollowUp(result, inputs));
+};
+const runAndPrintPipeline = async (inputs) => {
+	await Effect.runPromise(withRunControlStoreScoped(inputs.worktreePath, (store) => Effect.tryPromise({
+		catch: (error) => error,
+		try: async () => {
+			await runAndPrintPipelineWithStore(inputs, store);
+		}
+	})));
+};
+const scheduledEntrypointById = (config, id) => {
+	if (!Object.hasOwn(config.entrypoints, id)) return "";
+	return "schedule" in config.entrypoints[id] ? id : "";
+};
+const scheduledEntrypointId = (config, workflowId, entrypointId) => workflowId !== void 0 && workflowId !== "" ? "" : scheduledEntrypointById(config, entrypointId ?? "execute");
+const runConfiguredPipeline = async (rawInputs) => {
+	const inputs = withRunId(rawInputs);
+	const config = loadPipelineConfig(inputs.worktreePath, { allowMissingLintFileReferences: true });
+	if (inputs.schedule !== void 0 && inputs.schedule !== "") {
+		const scheduleYaml = readFileSync(inputs.schedule, "utf-8");
+		const compiled = compileScheduleArtifact(config, parseScheduleArtifact(scheduleYaml, inputs.schedule), inputs.worktreePath);
+		await runAndPrintPipeline({
+			...inputs,
+			config: compiled.config,
+			scheduleArtifact: scheduleYaml,
+			workflow: compiled.workflowId
+		});
+		return;
+	}
+	const scheduledEntrypoint = scheduledEntrypointId(config, inputs.workflow, inputs.entrypoint);
+	if (scheduledEntrypoint !== "") {
+		if (inputs.pipelineRunner !== void 0) {
+			await runAndPrintPipeline({
+				...inputs,
+				config
+			});
+			return;
+		}
+		const result = await generateScheduleArtifactInMemory({
+			config,
+			entrypointId: scheduledEntrypoint,
+			runId: inputs.runId,
+			task: inputs.task,
+			worktreePath: inputs.worktreePath
+		});
+		console.log("Schedule generated in memory");
+		const scheduleYaml = result.yaml;
+		const compiled = compileScheduleArtifact(config, parseScheduleArtifact(scheduleYaml, "schedule.yaml"), inputs.worktreePath);
+		await runAndPrintPipeline({
+			...inputs,
+			config: compiled.config,
+			scheduleArtifact: scheduleYaml,
+			workflow: compiled.workflowId
+		});
+		return;
+	}
+	await runAndPrintPipeline({
+		...inputs,
+		config
+	});
+};
+/**
+* Config-driven `execute` entrypoint. Package-owned defaults are the source of
+* truth; repo-local pipeline files are ignored by runtime loading.
+*/
+const execute = async (description, options = {}) => {
+	try {
+		if (!description.trim()) throw new Error("Task description is required");
+		const worktreePath = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
+		return runConfiguredPipeline({
+			entrypoint: options.entrypoint,
+			pipelineRunner: options.pipelineRunner,
+			runControl: options.runControl,
+			runId: options.runId,
+			runStoreMode: options.runStoreMode,
+			schedule: options.schedule,
+			supervised: options.supervised,
+			supervisor: options.supervisor,
+			task: description,
+			workflow: options.workflow,
+			worktreePath
+		});
+	} catch (error) {
+		await Promise.reject(error);
+		return;
+	}
+};
+const quick = async (description, options = {}) => {
+	await execute(description, {
+		...options,
+		entrypoint: "quick",
+		runControl: {
+			...options.runControl,
+			effort: "quick"
+		}
+	});
+};
+const runLocalResolvedTask = async (task, execution, runControl) => {
+	await execute(task, {
+		entrypoint: execution.entrypoint,
+		runControl,
+		schedule: execution.schedule,
+		supervised: true,
+		workflow: execution.workflow
+	});
+};
+const prepareDetachedRun = async (input) => {
+	if (input.execution.schedule !== void 0 && input.execution.schedule !== "") {
 		const schedule = resolve(input.execution.schedule);
-		const scheduleYaml = readFileSync(schedule, "utf8");
+		const scheduleYaml = readFileSync(schedule, "utf-8");
 		const compiled = compileScheduleArtifact(input.config, parseScheduleArtifact(scheduleYaml, schedule), input.worktreePath);
 		return {
 			config: compiled.config,
@@ -325,7 +295,7 @@ async function prepareDetachedRun(input) {
 		};
 	}
 	const scheduledEntrypoint = scheduledEntrypointId(input.config, input.execution.workflow, input.execution.entrypoint);
-	if (!scheduledEntrypoint) return {
+	if (scheduledEntrypoint === "") return {
 		config: input.config,
 		entrypoint: input.execution.entrypoint,
 		workflow: input.execution.workflow
@@ -345,6 +315,26 @@ async function prepareDetachedRun(input) {
 		scheduleArtifact: scheduleYaml,
 		workflow: compiled.workflowId
 	};
-}
+};
+const runDetachedResolvedTask = async (task, execution, runControl) => {
+	const worktreePath = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
+	const runId = generateRuntimeRunId();
+	const config = loadPipelineConfig(worktreePath, { allowMissingLintFileReferences: true });
+	const prepared = await prepareDetachedRun({
+		config,
+		execution,
+		runId,
+		task,
+		worktreePath
+	});
+	await persistDetachedRunController({
+		prepared,
+		runControl,
+		runId,
+		task,
+		worktreePath
+	});
+	console.log(formatDetachedRunFollowUp(runId));
+};
 //#endregion
 export { execute, quick, runDetachedResolvedTask, runLocalResolvedTask };