@oisincoveney/pipeline 3.24.2 → 4.0.0

package/dist/cli/program.js

@@ -1,8 +1,10 @@
 import { loadPipelineConfig } from "../config/load.js";
 import "../config.js";
 import { registerBenchCommand } from "../commands/bench-command.js";
+import { registerCoordinatorCommand } from "../commands/coordinator-command.js";
 import { registerConfiguredEntrypointCommands } from "../commands/pipeline-command.js";
 import { registerRunnerCommandCommand } from "../commands/runner-command-command.js";
+import { registerRunnerNodeCommand } from "../commands/runner-node-command.js";
 import { registerTicketCommand } from "../commands/ticket-command.js";
 import { addMokaSubmitOptions, runMokaSubmitFromCli } from "./submit-options.js";
 import { registerRunControlCommands } from "../run-control/commands.js";
@@ -13,21 +15,16 @@ import { registerMcpGatewayCommands } from "./mcp-gateway-commands.js";
 import { registerPlanCommands } from "./plan-commands.js";
 import { execute } from "./run-service.js";
 import { printMokaSubmitResult, registerRunCommands } from "./run-commands.js";
-import { Effect } from "effect";
 import { readFileSync } from "node:fs";
+import { Effect } from "effect";
 import { Command, Help } from "commander";
 //#region src/cli/program.ts
-function createCliProgram(options = {}) {
-	const configuredPipeline = loadConfiguredEntrypoints(process.env.PIPELINE_TARGET_PATH ?? process.cwd());
-	const program = createBaseProgram();
-	registerApplicationCommands(program, options);
-	registerEntrypointCommands(program, configuredPipeline);
-	return program;
-}
-function createBaseProgram() {
-	return new Command().name("moka").description("Submit work to Momokaya").version(readPackageVersion()).exitOverride();
-}
-function registerApplicationCommands(program, options) {
+const registerSubmitCommand = (program) => {
+	addMokaSubmitOptions(program.command("submit").description("Submit work to Momokaya as an Argo Workflow.").argument("[input...]", "task description, or command argv with --command")).action(async (input, flags) => {
+		printMokaSubmitResult(await runMokaSubmitFromCli(input, flags));
+	});
+};
+const registerApplicationCommands = (program, options) => {
 	const dispatchResolvedRunCommand = registerRunCommands(program, { runCommand: options.runCommand });
 	registerRunControlCommands(program);
 	registerPlanCommands(program);
@@ -37,49 +34,50 @@ function registerApplicationCommands(program, options) {
 	registerLoopCommand(program);
 	registerFactoryCommands(program);
 	registerRunnerCommandCommand(program);
+	registerRunnerNodeCommand(program);
+	registerCoordinatorCommand(program);
 	registerBenchCommand(program);
 	registerTicketCommand(program, {
 		...options.ticketCommand,
 		runCommand: options.ticketCommand?.runCommand ?? dispatchResolvedRunCommand
 	});
-}
-function registerSubmitCommand(program) {
-	addMokaSubmitOptions(program.command("submit").description("Submit work to Momokaya as an Argo Workflow.").argument("[input...]", "task description, or command argv with --command")).action(async (input, flags) => {
-		printMokaSubmitResult(await runMokaSubmitFromCli(input, flags));
-	});
-}
-function registerEntrypointCommands(program, configuredPipeline) {
-	configureEntrypointHelp(program, registerConfiguredEntrypointCommands(program, configuredPipeline, runEntrypointCommand));
-}
-function configureEntrypointHelp(program, configuredEntrypointCommands) {
+};
+const configureEntrypointHelp = (program, configuredEntrypointCommands) => {
 	if (configuredEntrypointCommands.size === 0) return;
 	program.configureHelp({ subcommandTerm(command) {
 		if (configuredEntrypointCommands.has(command.name())) return command.name();
 		return Help.prototype.subcommandTerm.call(this, command);
 	} });
-}
-function runEntrypointCommand(entrypoint, task) {
-	return execute(task, { entrypoint });
-}
-function readPackageVersion() {
-	const packageJson = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
+};
+const runEntrypointCommand = async (entrypoint, task) => {
+	await execute(task, { entrypoint });
+};
+const registerEntrypointCommands = (program, configuredPipeline) => {
+	const configuredEntrypointCommands = registerConfiguredEntrypointCommands(program, configuredPipeline, runEntrypointCommand);
+	configureEntrypointHelp(program, configuredEntrypointCommands);
+};
+const isPackageVersionRecord = (value) => typeof value === "object" && value !== null && "version" in value && typeof value.version === "string";
+const readPackageVersion = () => {
+	const packageJson = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf-8"));
 	if (!isPackageVersionRecord(packageJson)) throw new Error("Unable to read @oisincoveney/pipeline package version.");
 	return packageJson.version;
-}
-function isPackageVersionRecord(value) {
-	return typeof value === "object" && value !== null && "version" in value && typeof value.version === "string";
-}
-function loadConfiguredEntrypoints(cwd) {
-	return loadPipelineConfig(cwd, { allowMissingLintFileReferences: true });
-}
-function runCliEffect(argv) {
-	return Effect.tryPromise({
-		catch: (error) => error,
-		try: () => createCliProgram().parseAsync(argv, { from: "node" })
-	}).pipe(Effect.asVoid);
-}
-async function runCli(argv) {
+};
+const createBaseProgram = () => new Command().name("moka").description("Submit work to Momokaya").version(readPackageVersion()).exitOverride();
+const loadConfiguredEntrypoints = (cwd) => loadPipelineConfig(cwd, { allowMissingLintFileReferences: true });
+const createCliProgram = (options = {}) => {
+	const cwd = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
+	const configuredPipeline = loadConfiguredEntrypoints(cwd);
+	const program = createBaseProgram();
+	registerApplicationCommands(program, options);
+	registerEntrypointCommands(program, configuredPipeline);
+	return program;
+};
+const runCliEffect = (argv) => Effect.tryPromise({
+	catch: (error) => error,
+	try: async () => await createCliProgram().parseAsync(argv, { from: "node" })
+}).pipe(Effect.asVoid);
+const runCli = async (argv) => {
 	await createCliProgram().parseAsync(argv, { from: "node" });
-}
+};
 //#endregion
 export { createCliProgram, runCli, runCliEffect };

package/dist/cli/run-command.d.ts

@@ -1,5 +1,5 @@
+import "../run-control/contracts.js";
 import { RunResolution, RunResolverFlags } from "./run-resolver.js";
-
 //#region src/cli/run-command.d.ts
 interface RunCommandCall {
   readonly descriptionParts: string[];

package/dist/cli/run-command.js

@@ -1,12 +1,25 @@
 //#region src/cli/run-command.ts
-async function dispatchMokaRunCommand(call, dependencies) {
-	if (dependencies.runCommand) {
-		await dependencies.runCommand(call);
+const localRunDispatchInput = (call, execution) => {
+	const { resolution, task } = call;
+	return {
+		execution,
+		runControl: {
+			effort: resolution.effort,
+			mode: resolution.mode === "read" ? "read-only" : "write",
+			target: resolution.target
+		},
+		task
+	};
+};
+const dispatchLocalMokaRunCommand = async (call, execution, dependencies) => {
+	const localDispatchInput = localRunDispatchInput(call, execution);
+	if (call.flags.detach === true) {
+		await dependencies.runDetached(localDispatchInput);
 		return;
 	}
-	await dispatchResolvedMokaRunCommand(call, dependencies);
-}
-async function dispatchResolvedMokaRunCommand(call, dependencies) {
+	await dependencies.runLocal(localDispatchInput);
+};
+const dispatchResolvedMokaRunCommand = async (call, dependencies) => {
 	const { resolution } = call;
 	const { execution } = resolution;
 	if (execution.kind === "remote-submit") {
@@ -17,26 +30,13 @@ async function dispatchResolvedMokaRunCommand(call, dependencies) {
 		return;
 	}
 	await dispatchLocalMokaRunCommand(call, execution, dependencies);
-}
-async function dispatchLocalMokaRunCommand(call, execution, dependencies) {
-	const localDispatchInput = localRunDispatchInput(call, execution);
-	if (call.flags.detach) {
-		await dependencies.runDetached(localDispatchInput);
+};
+const dispatchMokaRunCommand = async (call, dependencies) => {
+	if (dependencies.runCommand) {
+		await dependencies.runCommand(call);
 		return;
 	}
-	await dependencies.runLocal(localDispatchInput);
-}
-function localRunDispatchInput(call, execution) {
-	const { resolution, task } = call;
-	return {
-		execution,
-		runControl: {
-			effort: resolution.effort,
-			mode: resolution.mode === "read" ? "read-only" : "write",
-			target: resolution.target
-		},
-		task
-	};
-}
+	await dispatchResolvedMokaRunCommand(call, dependencies);
+};
 //#endregion
 export { dispatchMokaRunCommand };

package/dist/cli/run-commands.js

@@ -4,17 +4,42 @@ import { dispatchMokaRunCommand } from "./run-command.js";
 import { execute, runDetachedResolvedTask, runLocalResolvedTask } from "./run-service.js";
 import { Option } from "commander";
 //#region src/cli/run-commands.ts
-function registerRunCommands(program, options = {}) {
+const remoteSubmitFlags = (execution) => ({
+	command: execution.command,
+	quick: execution.mode === "quick",
+	schedule: execution.schedule
+});
+const printMokaSubmitResult = (result) => {
+	console.log(`Workflow submitted: ${result.workflowName} in ${result.namespace}`);
+	if (result.workflowUid !== void 0 && result.workflowUid !== "") console.log(`Workflow UID: ${result.workflowUid}`);
+};
+const createResolvedRunCommand = (options) => async (call) => {
+	await dispatchMokaRunCommand(call, {
+		runCommand: options.runCommand,
+		runDetached: async ({ execution, runControl, task: resolvedTask }) => {
+			await runDetachedResolvedTask(resolvedTask, execution, runControl);
+		},
+		runLocal: async ({ execution, runControl, task: resolvedTask }) => {
+			await runLocalResolvedTask(resolvedTask, execution, runControl);
+		},
+		runRemoteSubmit: async ({ descriptionParts: parts, execution }) => {
+			const result = await runMokaSubmitFromCli(parts, remoteSubmitFlags(execution));
+			printMokaSubmitResult(result);
+		}
+	});
+};
+const registerRunCommands = (program, options = {}) => {
 	const dispatchResolvedRunCommand = createResolvedRunCommand(options);
 	program.command("run").description("Primary command: run a workflow from package-owned @oisincoveney/pipeline config").argument("<description...>", "task description").option("--command", "treat input after -- as explicit argv for remote submission").option("--entrypoint <entrypoint>", "entrypoint id from package config").option("--detach", "start a supervised controller process in the background").addOption(new Option("--effort <effort>", "run effort").choices([...MOKA_RUN_EFFORTS]).default("normal")).option("--read-only", "run the read-only inspect workflow").option("--schedule <schedule>", "approved schedule YAML to execute").addOption(new Option("--target <target>", "execution target").choices([...MOKA_RUN_TARGETS]).default("local")).option("--workflow <workflow>", "workflow id from package config").action(async (descriptionParts, flags) => {
 		const task = descriptionParts.join(" ");
+		const resolution = resolveMokaRun({
+			flags,
+			task
+		});
 		await dispatchResolvedRunCommand({
 			descriptionParts,
 			flags,
-			resolution: resolveMokaRun({
-				flags,
-				task
-			}),
+			resolution,
 			task
 		});
 	});
@@ -30,29 +55,6 @@ function registerRunCommands(program, options = {}) {
 		});
 	});
 	return dispatchResolvedRunCommand;
-}
-function createResolvedRunCommand(options) {
-	return async (call) => {
-		await dispatchMokaRunCommand(call, {
-			runCommand: options.runCommand,
-			runDetached: ({ execution, runControl, task: resolvedTask }) => runDetachedResolvedTask(resolvedTask, execution, runControl),
-			runLocal: ({ execution, runControl, task: resolvedTask }) => runLocalResolvedTask(resolvedTask, execution, runControl),
-			runRemoteSubmit: async ({ descriptionParts: parts, execution }) => {
-				printMokaSubmitResult(await runMokaSubmitFromCli(parts, remoteSubmitFlags(execution)));
-			}
-		});
-	};
-}
-function remoteSubmitFlags(execution) {
-	return {
-		command: execution.command,
-		quick: execution.mode === "quick",
-		schedule: execution.schedule
-	};
-}
-function printMokaSubmitResult(result) {
-	console.log(`Workflow submitted: ${result.workflowName} in ${result.namespace}`);
-	if (result.workflowUid) console.log(`Workflow UID: ${result.workflowUid}`);
-}
+};
 //#endregion
 export { printMokaSubmitResult, registerRunCommands };

package/dist/cli/run-resolver.d.ts

@@ -21,7 +21,7 @@ interface LocalRuntimeExecution {
   workflow?: string;
 }
 interface RemoteSubmitExecution {
-  command?: boolean;
+  command: boolean;
   kind: "remote-submit";
   mode: "full" | "quick";
   schedule?: string;

package/dist/cli/run-resolver.js

@@ -5,45 +5,30 @@ const MOKA_RUN_EFFORTS = [
 	"thorough"
 ];
 const MOKA_RUN_TARGETS = ["local", "remote"];
-function resolveMokaRun(input) {
-	const flags = input.flags ?? {};
-	const effort = flags.effort ?? "normal";
-	const target = flags.target ?? "local";
-	const mode = flags.readOnly ? "read" : "write";
-	assertFlagTargetCompatibility(flags, target);
-	return {
-		effort,
-		execution: target === "remote" ? resolveRemoteSubmit(flags, effort) : resolveLocalRuntime(flags, effort),
-		mode,
-		target
-	};
-}
-function assertFlagTargetCompatibility(flags, target) {
-	if (flags.command && target !== "remote") throw new Error("--command requires --target remote");
-	if (flags.detach && target !== "local") throw new Error("--detach requires --target local");
-}
-function resolveRemoteSubmit(flags, effort) {
-	return {
-		command: flags.command,
-		kind: "remote-submit",
-		mode: effort === "quick" ? "quick" : "full",
-		schedule: flags.schedule
-	};
-}
+const assertFlagTargetCompatibility = (flags, target) => {
+	if (flags.command === true && target !== "remote") throw new Error("--command requires --target remote");
+	if (flags.detach === true && target !== "local") throw new Error("--detach requires --target local");
+};
+const resolveRemoteSubmit = (flags, effort) => ({
+	command: flags.command === true,
+	kind: "remote-submit",
+	mode: effort === "quick" ? "quick" : "full",
+	schedule: flags.schedule
+});
 const LOCAL_RUNTIME_RESOLVERS = [
-	(flags) => flags.schedule ? {
+	(flags) => flags.schedule !== void 0 && flags.schedule !== "" ? {
 		kind: "local-runtime",
 		schedule: flags.schedule
 	} : void 0,
-	(flags) => flags.workflow ? {
+	(flags) => flags.workflow !== void 0 && flags.workflow !== "" ? {
 		kind: "local-runtime",
 		workflow: flags.workflow
 	} : void 0,
-	(flags) => flags.readOnly ? {
+	(flags) => flags.readOnly === true ? {
 		kind: "local-runtime",
 		workflow: "inspect"
 	} : void 0,
-	(flags) => flags.entrypoint ? {
+	(flags) => flags.entrypoint !== void 0 && flags.entrypoint !== "" ? {
 		entrypoint: flags.entrypoint,
 		kind: "local-runtime"
 	} : void 0,
@@ -56,12 +41,25 @@ const LOCAL_RUNTIME_RESOLVERS = [
 		kind: "local-runtime"
 	} : void 0
 ];
-function resolveLocalRuntime(flags, effort) {
+const resolveLocalRuntime = (flags, effort) => {
 	for (const resolve of LOCAL_RUNTIME_RESOLVERS) {
 		const resolved = resolve(flags, effort);
-		if (resolved) return resolved;
+		if (resolved !== void 0) return resolved;
 	}
 	return { kind: "local-runtime" };
-}
+};
+const resolveMokaRun = (input) => {
+	const flags = input.flags ?? {};
+	const effort = flags.effort ?? "normal";
+	const target = flags.target ?? "local";
+	const mode = flags.readOnly === true ? "read" : "write";
+	assertFlagTargetCompatibility(flags, target);
+	return {
+		effort,
+		execution: target === "remote" ? resolveRemoteSubmit(flags, effort) : resolveLocalRuntime(flags, effort),
+		mode,
+		target
+	};
+};
 //#endregion
 export { MOKA_RUN_EFFORTS, MOKA_RUN_TARGETS, resolveMokaRun };

package/dist/cli/run-service.d.ts

@@ -1,6 +1,5 @@
 import { RunEffort, RunMode, RunTarget } from "../run-control/contracts.js";
 import { runPipelineFromConfig } from "../pipeline-runtime.js";
-
 //#region src/cli/run-service.d.ts
 interface ExecuteOptions {
   entrypoint?: string;
@@ -23,7 +22,7 @@ interface RunControlOptions {
  * Config-driven `execute` entrypoint. Package-owned defaults are the source of
  * truth; repo-local pipeline files are ignored by runtime loading.
  */
-declare function execute(description: string, options?: ExecuteOptions): Promise<void>;
-declare function quick(description: string, options?: Omit<ExecuteOptions, "entrypoint">): Promise<void>;
+declare const execute: (description: string, options?: ExecuteOptions) => Promise<void>;
+declare const quick: (description: string, options?: Omit<ExecuteOptions, "entrypoint">) => Promise<void>;
 //#endregion
 export { ExecuteOptions, RunControlOptions, RunStoreMode, execute, quick };