@oisincoveney/pipeline 3.15.1 → 3.15.3

package/defaults/profiles.yaml

@@ -154,6 +154,7 @@ profiles:
     runner: opencode
     scheduling_roles: [implementation]
     description: Add focused failing tests for the requested behavior.
+    timeout_ms: 900000
     instructions: { inline: "Add focused failing tests for the requested behavior only. Do not change production code. Only edit files matching test paths such as **/*.test.*, **/*.spec.*, **/*_test.*, **/__tests__/**, test/**, or tests/**. NEVER silence lint, type, complexity, or dead-code findings with suppression comments (no // fallow-ignore, // biome-ignore, eslint-disable, oxlint-disable, @ts-ignore, or @ts-expect-error); fix the underlying cause — if a gate flags your test, restructure the test (e.g. move restricted imports into shared support/fixture helpers) rather than suppressing it. Return only valid JSON with top-level changes and verification. Every changes entry must include summary, why, and files. Include risks, followups, and lessons when present. Do not use Markdown fences or prose outside the JSON object." }
     skills: [test]
     mcp_servers: [pipeline-gateway]
@@ -168,6 +169,7 @@ profiles:
     runner: opencode
     scheduling_roles: [implementation]
     description: Implement production code until the failing tests pass.
+    timeout_ms: 900000
     instructions: { inline: "Implement the smallest production change that satisfies the failing tests. NEVER silence lint, type, complexity, or dead-code findings with suppression comments (no // fallow-ignore, // biome-ignore, eslint-disable, oxlint-disable, @ts-ignore, or @ts-expect-error); fix the underlying cause — reduce complexity by extracting helpers, remove genuinely dead code, and migrate off deprecated APIs rather than suppressing the warning. Return only valid JSON with top-level changes and verification. Every changes entry must include summary, why, and files. Include risks, followups, and lessons when present. Do not use Markdown fences or prose outside the JSON object." }
     skills: [trace, test, fix, library-first-development]
     mcp_servers: [pipeline-gateway]

package/dist/argo-graph.js

@@ -1,5 +1,6 @@
 import { uniqueStrings } from "./strings.js";
 import { resolveExecutableDependencyIds } from "./planning/dependency-refs.js";
+import { terminalDependencyItems } from "./planning/graph.js";
 import { z } from "zod";
 import { Data } from "effect";
 //#region src/argo-graph.ts
@@ -43,10 +44,11 @@ var ArgoGraphCompiler = class {
 	}
 	compile() {
 		this.compileNodes(this.plan.topologicalOrder, []);
+		const terminalTasks = this.terminalTasks();
 		return {
-			terminalNodeIds: this.terminalTasks().map((task) => task.nodeId),
+			terminalNodeIds: terminalTasks.map((task) => task.nodeId),
 			tasks: this.tasks,
-			terminalTaskNames: this.terminalTasks().map((task) => task.taskName),
+			terminalTaskNames: terminalTasks.map((task) => task.taskName),
 			workflowId: this.plan.workflowId
 		};
 	}
@@ -92,8 +94,7 @@ var ArgoGraphCompiler = class {
 		return uniqueStrings(resolveExecutableDependencyIds(this.nodeById, nodeIds).map((id) => argoTaskName(id)));
 	}
 	terminalTasks() {
-		const dependedOn = new Set(this.tasks.flatMap((task) => task.dependencies));
-		return this.tasks.filter((task) => !dependedOn.has(task.taskName));
+		return terminalDependencyItems(this.tasks, (task) => task.taskName, (task) => task.dependencies);
 	}
 };
 function argoTaskName(nodeId) {

package/dist/argo-submit.js

@@ -1,5 +1,5 @@
 import { ArgoGraphCompilerError, compileArgoExecutionGraph } from "./argo-graph.js";
-import { brokerAuthOptionSchema } from "./broker-auth.js";
+import { brokerAuthOptionSchema } from "./credentials/broker.js";
 import { compileScheduleArtifact, parseScheduleArtifact } from "./planning/generate.js";
 import { parseRunnerCommandPayload, runnerCommandPayloadSchema } from "./runner-command-contract.js";
 import { buildRunnerTaskDescriptor } from "./runner-command/task-descriptor.js";

package/dist/cli/bootstrap-commands.js

@@ -0,0 +1,34 @@
+import { formatCodexAuthSyncResult, syncLocalCodexAuth } from "../credentials/local-codex-auth-sync.js";
+import { formatPipelineInitResult, initPipelineProject } from "../pipeline-init.js";
+import { runDoctor } from "./doctor.js";
+import { formatDoctorResult } from "./format.js";
+import { resolve } from "node:path";
+//#region src/cli/bootstrap-commands.ts
+function registerBootstrapCommands(program) {
+	program.command("doctor").description("Check local prerequisites for pipeline init and execution").option("--cluster [namespace]", "also check runner-job Kubernetes prerequisites").option("--json", "print machine-readable readiness results").option("--kube-context <context>", "kubectl context for cluster checks").option("--kubeconfig <path>", "kubeconfig path for cluster checks").action(async (flags) => {
+		const result = await runDoctor(process.env.PIPELINE_TARGET_PATH ?? process.cwd(), flags);
+		console.log(flags.json ? JSON.stringify(result) : formatDoctorResult(result));
+		if (!result.passed) throw new Error("Doctor checks failed.");
+	});
+	program.command("init").description("Install or refresh package-owned pipeline support: per-machine harness (skills + slash-command adapters + agent hooks + global instruction files) installed globally to ~/.claude, ~/.config/opencode, ~/.codex with no repo-local config").option("--check", "verify the generated harness is current; fail if stale").option("--dry-run", "show planned changes without writing files").option("--force", "overwrite manually edited harness files").action(async (flags) => {
+		const result = await initPipelineProject({
+			...flags,
+			cwd: process.env.PIPELINE_TARGET_PATH ?? process.cwd()
+		});
+		console.log(formatPipelineInitResult(result, {
+			check: flags.check,
+			dryRun: flags.dryRun
+		}));
+	});
+	program.command("codex-auth").description("Manage local Codex broker auth integration").command("sync-local").description("Point local dev repos' opencode openai provider at the central CLIProxyAPI broker").option("--root <path>", "directory containing repositories to sync").option("--dry-run", "show planned changes without writing files").option("--check", "fail if local Codex auth config is not synced").action((flags) => {
+		const result = syncLocalCodexAuth({
+			check: flags.check,
+			dryRun: flags.dryRun,
+			root: resolve(flags.root ?? process.env.PIPELINE_TARGET_PATH ?? process.cwd())
+		});
+		console.log(formatCodexAuthSyncResult(result));
+		if (!result.ok) process.exitCode = 1;
+	});
+}
+//#endregion
+export { registerBootstrapCommands };

package/dist/cli/loop-commands.js

@@ -0,0 +1,49 @@
+import { loadPipelineConfig } from "../config/load.js";
+import "../config.js";
+import { loadMokaGlobalConfig } from "../moka-global-config.js";
+import { parseLoopFlags, runLoopSubmit } from "../loop/loop-command.js";
+import { runLoopControllerEntrypoint } from "../loop/loop-controller-entrypoint.js";
+import { Option } from "commander";
+//#region src/cli/loop-commands.ts
+function registerLoopCommand(program) {
+	program.command("loop").description("Submit a long-running cloud controller that drains the backlog ticket-by-ticket").addOption(new Option("--strategy <strategy>", "ready-ticket selection strategy").choices([
+		"priority",
+		"bfs",
+		"dfs"
+	]).default("priority")).option("--root <epic-id>", "restrict traversal to this epic subtree").option("--max-remediation-attempts <n>", "bounded fix-up submits before a PR is declared blocked").option("--merge-timeout <n>", "bounded merge polls before an indeterminate PR is declared blocked").action(async (options) => {
+		const result = await runLoopSubmit(buildLoopSubmitInput(options));
+		console.log(`Loop controller submitted: ${result.workflowName} in ${result.namespace}`);
+	});
+	program.command("loop-controller", { hidden: true }).description("Internal in-cluster loop controller process").requiredOption("--payload-file <path>", "Path to the runner payload JSON").addOption(new Option("--strategy <strategy>", "ready-ticket selection strategy").choices([
+		"priority",
+		"bfs",
+		"dfs"
+	]).default("priority")).option("--root <epic-id>", "restrict traversal to this epic subtree").option("--max-remediation-attempts <n>", "bounded fix-up submits").option("--merge-timeout <n>", "bounded merge polls").action(async (flags) => {
+		await runLoopControllerEntrypoint({
+			flags: parseLoopFlags(flags),
+			payloadFile: flags.payloadFile,
+			worktreePath: process.env.PIPELINE_TARGET_PATH ?? process.cwd()
+		});
+	});
+}
+function buildLoopSubmitInput(options) {
+	const cwd = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
+	const config = loadPipelineConfig(cwd, { allowMissingLintFileReferences: true });
+	const momokaya = loadMokaGlobalConfig()?.momokaya;
+	const brokerAuth = momokaya?.submit.brokerAuth;
+	if (!brokerAuth) throw new Error("momokaya.submit.brokerAuth is required for moka loop submit");
+	return {
+		brokerAuth,
+		config,
+		eventUrl: momokaya?.submit.eventUrl,
+		flags: parseLoopFlags(options),
+		gitCredentialsSecretName: momokaya?.submit.gitCredentialsSecretName,
+		githubAuthSecretName: momokaya?.submit.githubAuthSecretName,
+		kubeconfigPath: momokaya?.kubernetes.kubeconfig,
+		namespace: momokaya?.kubernetes.namespace,
+		serviceAccountName: momokaya?.submit.serviceAccountName,
+		worktreePath: cwd
+	};
+}
+//#endregion
+export { registerLoopCommand };

package/dist/cli/mcp-gateway-commands.js

@@ -0,0 +1,60 @@
+import { loadPipelineConfig } from "../config/load.js";
+import "../config.js";
+import { renderGatewayConfig } from "../mcp/gateway-config.js";
+import { formatDoctorResult } from "./format.js";
+import { runGatewayDoctor } from "../mcp/gateway-doctor.js";
+import { localGatewayStatus, reconcileGateway, startLocalGateway } from "../mcp/gateway-reconcile.js";
+import { configureGatewayHosts } from "../mcp/host-config.js";
+import { Option } from "commander";
+//#region src/cli/mcp-gateway-commands.ts
+function registerMcpGatewayCommands(program) {
+	const gatewayCommand = program.command("mcp").description("Manage the hosted-first MCP gateway").command("gateway").description("Inspect and configure the pipeline MCP gateway");
+	gatewayCommand.command("doctor").description("Check MCP gateway configuration and legacy direct MCP entries").action(async () => {
+		const cwd = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
+		const result = await runGatewayDoctor(loadPipelineConfig(cwd, { allowMissingLintFileReferences: true }), cwd);
+		console.log(formatDoctorResult(result));
+		if (!result.passed) throw new Error("MCP gateway doctor checks failed.");
+	});
+	gatewayCommand.command("config").description("Print resolved MCP gateway client configuration").action(() => {
+		const config = loadPipelineConfig(process.env.PIPELINE_TARGET_PATH ?? process.cwd(), { allowMissingLintFileReferences: true });
+		console.log(renderGatewayConfig(config));
+	});
+	gatewayCommand.command("configure-host").description("Rewrite host MCP config to the singleton pipeline gateway").addOption(new Option("--host <host>", "host config to update").choices(["all", "opencode"]).default("all").argParser(parseGatewayHost)).addOption(new Option("--scope <scope>", "config scope to update").choices(["project", "global"]).default("project").argParser(parseGatewayHostScope)).action((flags) => {
+		const cwd = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
+		const result = configureGatewayHosts(loadPipelineConfig(cwd, { allowMissingLintFileReferences: true }), {
+			cwd,
+			host: flags.host ?? "all",
+			scope: flags.scope ?? "project"
+		});
+		console.log(result.map((item) => [`${item.host}: ${item.path}`, item.backupPath ? `backup=${item.backupPath}` : "backup=none"].join(" ")).join("\n"));
+	});
+	gatewayCommand.command("reconcile").description("Apply the current workspace gateway backend inventory").action(async () => {
+		const cwd = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
+		const result = await reconcileGateway(loadPipelineConfig(cwd, { allowMissingLintFileReferences: true }), cwd);
+		console.log([
+			`workspace=${result.workspacePath}`,
+			`config=${result.configPath}`,
+			`backends=${result.backendCount}`,
+			result.readinessFailures.length > 0 ? `readiness_failures=${result.readinessFailures.join("; ")}` : "readiness_failures=none"
+		].join("\n"));
+	});
+	gatewayCommand.command("local-start").description("Start a local ToolHive vMCP gateway for local mode").option("--detach", "reserved for future background startup", false).action(async (flags) => {
+		if (flags.detach) throw new Error("Detached local gateway startup is not implemented.");
+		const cwd = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
+		await startLocalGateway(loadPipelineConfig(cwd, { allowMissingLintFileReferences: true }), cwd);
+	});
+	gatewayCommand.command("local-status").description("Show local ToolHive MCP server status").action(async () => {
+		const cwd = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
+		console.log(await localGatewayStatus(cwd));
+	});
+}
+function parseGatewayHostScope(value) {
+	if (value === "project" || value === "global") return value;
+	throw new Error("scope must be project or global");
+}
+function parseGatewayHost(value) {
+	if (value === "all" || value === "opencode") return value;
+	throw new Error("host must be all or opencode");
+}
+//#endregion
+export { registerMcpGatewayCommands };

package/dist/cli/plan-commands.js

@@ -0,0 +1,156 @@
+import { loadPipelineConfig } from "../config/load.js";
+import "../config.js";
+import { compileWorkflowPlan } from "../planning/compile.js";
+import { resolveWorkflowSelection } from "../runtime/context/context.js";
+import "../runtime/context/index.js";
+import { createOrchestratorLaunchPlan, createRunnerLaunchPlan } from "../runner.js";
+import { compileScheduleArtifact, parseScheduleArtifact } from "../planning/generate.js";
+import { formatConfigLintWarning, lintPipelineConfig } from "../config/lint.js";
+import { readFileSync } from "node:fs";
+//#region src/cli/plan-commands.ts
+function registerPlanCommands(program) {
+	program.command("validate").description("Validate package-owned @oisincoveney/pipeline config and compile the workflow plan").option("--entrypoint <entrypoint>", "entrypoint id from package config").option("--schedule <schedule>", "approved schedule YAML to validate").option("--strict", "fail when validation lint warnings are emitted").option("--no-lint", "skip validation lint warnings").option("--workflow <workflow>", "workflow id from package config").action((flags) => runValidateCommand(flags));
+	program.command("explain-plan").description("Explain nodes, runners, gates, hooks, and artifacts").option("--entrypoint <entrypoint>", "entrypoint id from package config").option("--schedule <schedule>", "approved schedule YAML to explain").option("--workflow <workflow>", "workflow id from package config").action((flags) => runExplainPlanCommand(flags));
+}
+function runValidateCommand(flags) {
+	const context = loadPlanConfigContext();
+	const selected = selectWorkflowPlan(context, flags);
+	const warnings = lintWarnings(context, flags);
+	emitLintWarnings(warnings);
+	assertStrictLintPass(flags, warnings);
+	console.log(formatValidationResult(selected.plan));
+}
+function runExplainPlanCommand(flags) {
+	const context = loadPlanConfigContext();
+	const selected = selectWorkflowPlan(context, flags);
+	console.log(formatCompiledWorkflowPlan(selected.config, context.cwd, selected.plan));
+}
+function loadPlanConfigContext() {
+	const cwd = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
+	return {
+		config: loadPipelineConfig(cwd, { allowMissingLintFileReferences: true }),
+		cwd
+	};
+}
+function selectWorkflowPlan(context, flags) {
+	if (flags.schedule) return scheduledWorkflowPlan(context, flags.schedule);
+	return configuredWorkflowPlan(context, flags);
+}
+function scheduledWorkflowPlan(context, schedulePath) {
+	const compiled = compileScheduleArtifact(context.config, parseScheduleArtifact(readFileSync(schedulePath, "utf8"), schedulePath), context.cwd);
+	return {
+		config: compiled.config,
+		plan: compiled.plan
+	};
+}
+function configuredWorkflowPlan(context, flags) {
+	return {
+		config: context.config,
+		plan: compileWorkflowPlan(context.config, resolveWorkflowSelection(context.config, flags.workflow, flags.entrypoint))
+	};
+}
+function lintWarnings(context, flags) {
+	return flags.lint === false ? [] : lintPipelineConfig(context.config, context.cwd);
+}
+function emitLintWarnings(warnings) {
+	for (const warning of warnings) console.error(formatConfigLintWarning(warning));
+}
+function assertStrictLintPass(flags, warnings) {
+	if (flags.strict && warnings.length > 0) throw new Error(`Validation failed with ${warnings.length} ${warningNoun(warnings.length)}.`);
+}
+function warningNoun(count) {
+	return count === 1 ? "warning" : "warnings";
+}
+function formatValidationResult(plan) {
+	return `OK: ${plan.workflowId} (${plan.topologicalOrder.length} nodes)`;
+}
+function formatCompiledWorkflowPlan(config, worktreePath, plan) {
+	return [
+		`Workflow: ${plan.workflowId}`,
+		formatOrchestratorPlan(config, worktreePath),
+		formatParallelBatches(plan),
+		...formatWorkflowNodes(plan, config, worktreePath),
+		...formatWorkflowHooks(config, plan.workflowId)
+	].join("\n");
+}
+function formatParallelBatches(plan) {
+	return `Batches: ${plan.parallelBatches.map(formatParallelBatch).join(" -> ")}`;
+}
+function formatParallelBatch(batch) {
+	return `[${batch.map((node) => node.id).join(", ")}]`;
+}
+function formatWorkflowNodes(plan, config, worktreePath) {
+	return plan.topologicalOrder.flatMap((node) => formatWorkflowNodeLines(node, config, worktreePath));
+}
+function formatWorkflowNodeLines(node, config, worktreePath) {
+	return [formatParallelChildrenLine(node), formatWorkflowPlanNode(node, config, worktreePath)].filter(isNonEmptyString);
+}
+function formatParallelChildrenLine(node) {
+	if (node.kind !== "parallel" || !node.children?.length) return "";
+	return `${node.id}(parallel: ${node.children.map((child) => child.id).join(", ")})`;
+}
+function formatWorkflowHooks(config, workflowId) {
+	const hooks = workflowHookIds(config, workflowId);
+	return hooks.length > 0 ? [`Workflow hooks: ${hooks.join(", ")}`] : [];
+}
+function workflowHookIds(config, workflowId) {
+	return Object.entries(config.hooks.on).flatMap(([event, bindings]) => bindings.filter((binding) => binding.where?.workflow === workflowId).map((binding) => `${event}:${binding.id}`));
+}
+function formatWorkflowPlanNode(node, config, worktreePath) {
+	return [
+		`- ${node.id}`,
+		`kind=${node.kind}`,
+		formatNeeds(node),
+		formatRunner(node, config, worktreePath),
+		formatGateCount(node),
+		formatArtifacts(node)
+	].filter(isNonEmptyString).join(" ");
+}
+function formatNeeds(node) {
+	return `needs=${node.needs.join(",") || "none"}`;
+}
+function formatRunner(node, config, worktreePath) {
+	const launch = runnerLaunchPlan(node, config, worktreePath);
+	return launch ? `runner=${launch.runnerId}` : "";
+}
+function runnerLaunchPlan(node, config, worktreePath) {
+	if (!node.profile) return null;
+	if (!config.profiles[node.profile]) return null;
+	return createRunnerLaunchPlan(config, {
+		nodeId: node.id,
+		profileId: node.profile,
+		prompt: "<task>",
+		worktreePath
+	});
+}
+function formatGateCount(node) {
+	return `gates=${node.gates?.length ?? 0}`;
+}
+function formatArtifacts(node) {
+	const paths = node.artifacts?.map((artifact) => artifact.path) ?? [];
+	return paths.length > 0 ? `artifacts=${paths.join(",")}` : "artifacts=none";
+}
+function formatOrchestratorPlan(config, worktreePath) {
+	if (!config.orchestrator) return "Orchestrator: not configured";
+	const orchestrator = config.profiles[config.orchestrator.profile];
+	return [
+		`Orchestrator: runner=${createOrchestratorLaunchPlan(config, {
+			nodeId: "orchestrator",
+			prompt: "<task>",
+			worktreePath
+		}).runnerId}`,
+		orchestrator.model ? `model=${orchestrator.model}` : "",
+		formatList("rules", orchestrator.rules),
+		formatList("skills", orchestrator.skills),
+		formatList("mcp_servers", orchestrator.mcp_servers),
+		formatList("hooks", Object.keys(config.hooks.functions))
+	].filter(Boolean).join(" ");
+}
+function formatList(label, items) {
+	return items?.length ? `${label}=${items.join(",")}` : "";
+}
+function isNonEmptyString(value) {
+	return value.length > 0;
+}
+//#endregion
+export { registerPlanCommands };

package/dist/cli/program.d.ts

@@ -1,34 +1,9 @@
-import { RunEffort, RunMode, RunTarget } from "../run-control/contracts.js";
 import { RunCommand } from "./run-command.js";
 import { TicketCommandOptions } from "../commands/ticket/shared.js";
-import { runPipelineFromConfig } from "../pipeline-runtime.js";
 import { Effect } from "effect";
 import { Command } from "commander";
 
 //#region src/cli/program.d.ts
-interface ExecuteOptions {
-  entrypoint?: string;
-  pipelineRunner?: typeof runPipelineFromConfig;
-  runControl?: RunControlOptions;
-  runId?: string;
-  runStoreMode?: RunStoreMode;
-  schedule?: string;
-  supervised?: boolean;
-  supervisor?: boolean;
-  workflow?: string;
-}
-type RunStoreMode = "create" | "reuse";
-interface RunControlOptions {
-  effort?: RunEffort;
-  mode?: RunMode;
-  target?: RunTarget;
-}
-/**
- * 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>;
 interface CliProgramOptions {
   readonly runCommand?: RunCommand;
   readonly ticketCommand?: TicketCommandOptions;
@@ -36,4 +11,4 @@ interface CliProgramOptions {
 declare function createCliProgram(options?: CliProgramOptions): Command;
 declare function runCli(argv: string[]): Promise<void>;
 //#endregion
-export { createCliProgram, execute, quick, runCli };
+export { createCliProgram, runCli };