@oisincoveney/pipeline 2.1.1 → 2.3.0

package/dist/opencode-project-config.js

@@ -1,36 +1,17 @@
-import { applyEdits, modify, parse } from "jsonc-parser";
+import { applyJsonEdit, ensureTrailingNewline, formatJson, parseJsonRecord, setIfMissing } from "./json-config-merge.js";
 //#region src/opencode-project-config.ts
-const JSON_FORMAT_OPTIONS = {
-	insertSpaces: true,
-	tabSize: 2
-};
 function mergeOpenCodeProjectConfig(currentText, projection) {
 	if (currentText === void 0) return {
 		content: formatJson(projection),
 		ok: true
 	};
-	const parsed = parseOpenCodeProjectConfig(currentText);
+	const parsed = parseJsonRecord(currentText);
 	if (!parsed.ok) return parsed;
 	return {
 		content: ensureTrailingNewline(applyOpenCodeProjection(currentText, parsed.value, projection)),
 		ok: true
 	};
 }
-function parseOpenCodeProjectConfig(currentText) {
-	const errors = [];
-	const value = parse(currentText, errors, {
-		allowTrailingComma: true,
-		disallowComments: false
-	});
-	if (errors.length > 0 || !isRecord(value)) return {
-		errors,
-		ok: false
-	};
-	return {
-		ok: true,
-		value
-	};
-}
 function applyOpenCodeProjection(currentText, parsed, projection) {
 	return applyProviderProjection(applyPluginProjection(applyMcpProjection(setIfMissing(setIfMissing(currentText, parsed, ["$schema"], projection.$schema), parsed, ["lsp"], projection.lsp), parsed, projection), parsed, projection), parsed, projection);
 }
@@ -49,18 +30,6 @@ function applyPluginProjection(content, parsed, projection) {
 	const plugins = mergePluginEntries(parsed.plugin, projection.plugin ?? []);
 	return plugins.length > 0 ? applyJsonEdit(content, ["plugin"], plugins) : content;
 }
-function setIfMissing(content, parsed, path, value) {
-	if (value === void 0 || hasPath(parsed, path)) return content;
-	return applyJsonEdit(content, path, value);
-}
-function hasPath(value, path) {
-	let cursor = value;
-	for (const segment of path) {
-		if (!(isRecord(cursor) && segment in cursor)) return false;
-		cursor = cursor[segment];
-	}
-	return true;
-}
 function mergePluginEntries(existing, projected) {
 	const projectedByKey = new Map(projected.map((plugin) => [pluginKey(plugin), plugin]));
 	const merged = [];
@@ -86,17 +55,5 @@ function pluginName(specifier) {
 	const versionSeparator = specifier.indexOf("@", 1);
 	return versionSeparator === -1 ? specifier : specifier.slice(0, versionSeparator);
 }
-function applyJsonEdit(content, path, value) {
-	return applyEdits(content, modify(content, path, value, { formattingOptions: JSON_FORMAT_OPTIONS }));
-}
-function formatJson(value) {
-	return `${JSON.stringify(value, null, 2)}\n`;
-}
-function ensureTrailingNewline(value) {
-	return value.endsWith("\n") ? value : `${value}\n`;
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 //#endregion
 export { mergeOpenCodeProjectConfig };

package/dist/pipeline-runtime.d.ts

@@ -1,6 +1,15 @@
 import { PipelineConfigError } from "./config/schemas.js";
 import { AcceptanceCriterion, HookRuntimePolicy, NodeExecutionState, NodeStatus, PipelineRuntimeEvent, PipelineRuntimeObservabilityLevel, PipelineRuntimeOptions, PipelineRuntimeResult, PipelineTaskContext, RuntimeFailure, RuntimeGateResult, RuntimeNodeResult, RuntimeStructuredOutput } from "./runtime/contracts/contracts.js";
 //#region src/pipeline-runtime.d.ts
+/**
+ * Top layer of the runtime-options stack (PIPE-74 B3). Extends
+ * {@link PipelineRuntimeOptions} for the schedule-driven path that runs a
+ * SINGLE workflow node (`nodeId`) in isolation, supplying that node's upstream
+ * `dependencyOutputs`. Full stack:
+ *   RunnerExecutionOptions (src/runner.ts)
+ *     < PipelineRuntimeOptions (src/runtime/contracts/contracts.ts)
+ *     < ScheduledWorkflowTaskRuntimeOptions (this type)
+ */
 interface ScheduledWorkflowTaskRuntimeOptions extends PipelineRuntimeOptions {
   dependencyOutputs?: Map<string, string> | Record<string, string>;
   nodeId: string;

package/dist/pipeline-runtime.js

@@ -1,3 +1,5 @@
+import { loadPipelineConfig } from "./config/load.js";
+import "./config.js";
 import { executeCommand } from "./runtime/command-executor/command-executor.js";
 import "./runtime/command-executor/index.js";
 import { parseJsonObject } from "./runtime/json-validation/json-validation.js";
@@ -17,24 +19,64 @@ import { diffChangedFiles, snapshotChangedFiles } from "./runtime/changed-files/
 import { evaluateNodeGates } from "./runtime/gates/gates.js";
 import "./runtime/gates/index.js";
 import { NodeStateTracker } from "./runtime/node-state-tracker.js";
+import { configUsesOpencode, leaseOpencodeRuntime } from "./runtime/opencode-runtime.js";
 import { executeParallelNode } from "./runtime/parallel-node/parallel-node.js";
 import "./runtime/parallel-node/index.js";
 import { decideNodeRetry, nodeRetryPolicy } from "./runtime/retry.js";
 import { LocalScheduler } from "./runtime/scheduler.js";
 //#region src/pipeline-runtime.ts
 function runPipelineFromConfig(options) {
-	return runPipelineWithContext(createRuntimeContext(options));
+	return withOpencodeRuntime(options, (resolved) => runPipelineWithContext(createRuntimeContext(resolved)));
 }
 function runScheduledWorkflowTask(options) {
 	const { dependencyOutputs, nodeId, ...runtimeOptions } = options;
-	const context = createRuntimeContext(runtimeOptions);
-	hydrateScheduledDependencyStates(context, nodeId);
-	hydrateDependencyOutputs(context, dependencyOutputs);
-	recordNodeEvent(context, nodeId, {
-		at: now(),
-		type: "READY"
+	return withOpencodeRuntime(runtimeOptions, (resolved) => {
+		const context = createRuntimeContext(resolved);
+		hydrateScheduledDependencyStates(context, nodeId);
+		hydrateDependencyOutputs(context, dependencyOutputs);
+		recordNodeEvent(context, nodeId, {
+			at: now(),
+			type: "READY"
+		});
+		return executePlannedNode(nodeId, context);
+	});
+}
+/**
+* When the config uses opencode and the caller did not inject an executor,
+* open one opencode server for the run, drive nodes through the SDK executor,
+* and tear the server down afterward. Command-only configs and callers that
+* supply their own executor (tests, embedders) are passed through untouched.
+*/
+async function withOpencodeRuntime(options, run) {
+	if (options.executor) return await run(options);
+	const { config, worktreePath } = resolveConfigForRun(options);
+	return configUsesOpencode(config) ? await runWithLeasedOpencode(options, config, worktreePath, run) : await run({
+		...options,
+		config
+	});
+}
+function resolveConfigForRun(options) {
+	const worktreePath = options.worktreePath ?? process.cwd();
+	return {
+		config: options.config ?? loadPipelineConfig(worktreePath),
+		worktreePath
+	};
+}
+async function runWithLeasedOpencode(options, config, worktreePath, run) {
+	const lease = await leaseOpencodeRuntime({
+		config,
+		...options.signal ? { signal: options.signal } : {},
+		worktreePath
 	});
-	return executePlannedNode(nodeId, context);
+	try {
+		return await run({
+			...options,
+			config,
+			executor: lease.executor
+		});
+	} finally {
+		await lease.release();
+	}
 }
 async function runPipelineWithContext(context) {
 	return finishRuntime(context, await new LocalScheduler({

package/dist/planned-node.js

@@ -1,10 +1,7 @@
+import { findNode } from "./planning/graph.js";
 //#region src/planned-node.ts
 function findPlannedNode(nodes, nodeId) {
-	for (const node of nodes) {
-		if (node.id === nodeId) return node;
-		const child = findPlannedNode(node.children ?? [], nodeId);
-		if (child) return child;
-	}
+	return findNode(nodes, nodeId, (node) => node.children);
 }
 //#endregion
 export { findPlannedNode };

package/dist/{workflow-planner.d.ts → planning/compile.d.ts}

@@ -1,7 +1,7 @@
-import { PipelineConfig, WorkflowNodeKind } from "./config/schemas.js";
+import { PipelineConfig, WorkflowNodeKind } from "../config/schemas.js";
 import { Graph } from "@dagrejs/graphlib";
 
-//#region src/workflow-planner.d.ts
+//#region src/planning/compile.d.ts
 type WorkflowPlannerErrorCode = "WORKFLOW_CYCLE" | "WORKFLOW_DUPLICATE_NODE" | "WORKFLOW_GROUP_REFERENCE" | "WORKFLOW_MISSING_DEPENDENCY" | "WORKFLOW_MISSING_WORKFLOW";
 interface WorkflowPlannerIssue {
   message: string;

package/dist/{workflow-planner.js → planning/compile.js}

@@ -1,6 +1,7 @@
-import { uniqueStrings } from "./strings.js";
+import { uniqueStrings } from "../strings.js";
+import { findDependencyCycles } from "./graph.js";
 import { Graph } from "@dagrejs/graphlib";
-//#region src/workflow-planner.ts
+//#region src/planning/compile.ts
 var WorkflowPlannerError = class extends Error {
 	code;
 	issues;
@@ -54,7 +55,7 @@ function validateNodeGraph(workflowId, nodes) {
 		...groupIssues(workflowId, nodes, nodeIds),
 		...dependencyIssues(workflowId, nodes, nodeIds)
 	];
-	if (duplicateIssues.length === 0) return [...issues, ...cycleIssues(workflowId, nodes, nodeIds)];
+	if (duplicateIssues.length === 0) return [...issues, ...cycleIssues(workflowId, nodes)];
 	return issues;
 }
 function duplicateNodeIssues(workflowId, nodes) {
@@ -100,92 +101,14 @@ function groupChildIssues(workflowId, node, nodeIds) {
 function isGroupNode(node) {
 	return node.kind === "group";
 }
-function cycleIssues(workflowId, nodes, nodeIds) {
-	return dependencyCycles(nodes, nodeIds).map((cycle) => {
+function cycleIssues(workflowId, nodes) {
+	return findDependencyCycles(nodes).map((cycle) => {
 		return {
 			path: `workflows.${workflowId}.nodes.${cycle[0] ?? "nodes"}.needs`,
 			message: `workflow '${workflowId}' contains dependency cycle: ${cycle.join(" -> ")}`
 		};
 	});
 }
-function dependencyCycles(nodes, nodeIds) {
-	const dependentsByNeed = dependentsByNeedMap(nodes, nodeIds);
-	const state = /* @__PURE__ */ new Map();
-	const path = [];
-	const pathIndex = /* @__PURE__ */ new Map();
-	const cycles = [];
-	const cycleKeys = /* @__PURE__ */ new Set();
-	for (const node of nodes) {
-		if (state.has(node.id)) continue;
-		visitForCycles(node.id, {
-			cycleKeys,
-			cycles,
-			dependentsByNeed,
-			path,
-			pathIndex,
-			state
-		});
-	}
-	return cycles;
-}
-function visitForCycles(startId, visitState) {
-	const frames = [{
-		index: 0,
-		nodeId: startId
-	}];
-	markVisiting(startId, visitState);
-	while (frames.length > 0) {
-		const frame = frames.at(-1);
-		if (!frame) return;
-		const dependentId = (visitState.dependentsByNeed.get(frame.nodeId) ?? [])[frame.index];
-		if (!dependentId) {
-			markDone(frame.nodeId, visitState);
-			frames.pop();
-			continue;
-		}
-		frame.index += 1;
-		const dependentState = visitState.state.get(dependentId);
-		if (dependentState === "visiting") {
-			recordCycle(dependentId, visitState);
-			continue;
-		}
-		if (dependentState === "done") continue;
-		markVisiting(dependentId, visitState);
-		frames.push({
-			index: 0,
-			nodeId: dependentId
-		});
-	}
-}
-function markVisiting(nodeId, visitState) {
-	visitState.state.set(nodeId, "visiting");
-	visitState.pathIndex.set(nodeId, visitState.path.length);
-	visitState.path.push(nodeId);
-}
-function markDone(nodeId, visitState) {
-	visitState.state.set(nodeId, "done");
-	visitState.pathIndex.delete(nodeId);
-	visitState.path.pop();
-}
-function recordCycle(nodeId, visitState) {
-	const startIndex = visitState.pathIndex.get(nodeId);
-	if (startIndex === void 0) return;
-	const cycle = visitState.path.slice(startIndex);
-	const key = [...cycle].sort().join("\0");
-	if (visitState.cycleKeys.has(key)) return;
-	visitState.cycleKeys.add(key);
-	visitState.cycles.push(cycle);
-}
-function dependentsByNeedMap(nodes, nodeIds) {
-	const dependentsByNeed = /* @__PURE__ */ new Map();
-	for (const node of nodes) for (const need of uniqueStrings(node.needs ?? [])) {
-		if (!nodeIds.has(need)) continue;
-		const dependents = dependentsByNeed.get(need) ?? [];
-		dependents.push(node.id);
-		dependentsByNeed.set(need, dependents);
-	}
-	return dependentsByNeed;
-}
 function topologicalOrderForPlan(graph) {
 	const visited = /* @__PURE__ */ new Set();
 	const inStack = /* @__PURE__ */ new Set();

package/dist/{schedule/planner.d.ts → planning/generate.d.ts}

@@ -1,9 +1,9 @@
 import { PipelineConfig } from "../config/schemas.js";
-import { WorkflowExecutionPlan } from "../workflow-planner.js";
+import { WorkflowExecutionPlan } from "./compile.js";
 import { AgentResult, RunnerExecutionOptions, RunnerLaunchPlan } from "../runner.js";
 import { z } from "zod";
 
-//#region src/schedule/planner.d.ts
+//#region src/planning/generate.d.ts
 declare const scheduleArtifactSchema: z.ZodObject<{
   generated_at: z.ZodString;
   kind: z.ZodLiteral<"pipeline-schedule">;
@@ -1575,6 +1575,20 @@ interface GenerateScheduleResult {
   artifact: ScheduleArtifact;
   path: string;
 }
+interface BacklogWorkUnit {
+  acceptance_criteria: Array<{
+    id: string;
+    text: string;
+  }>;
+  dependencies?: string[];
+  description?: string;
+  id: string;
+  title?: string;
+}
+interface SchedulePlanningContext {
+  parentWorkUnits: BacklogWorkUnit[];
+  workUnits: BacklogWorkUnit[];
+}
 declare function parseScheduleArtifact(source: string, sourcePath?: string): ScheduleArtifact;
 declare class ScheduleArtifactError extends Error {
   constructor(message: string);
@@ -1583,4 +1597,4 @@ declare function compileScheduleArtifact(config: PipelineConfig, artifact: Sched
 declare function generateScheduleArtifact(options: GenerateScheduleOptions): Promise<GenerateScheduleResult>;
 declare function scheduleArtifactPath(worktreePath: string, scheduleId: string): string;
 //#endregion
-export { CompiledScheduleArtifact, GenerateScheduleOptions, GenerateScheduleResult, ScheduleArtifact, ScheduleArtifactError, compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact, scheduleArtifactPath };
+export { BacklogWorkUnit, CompiledScheduleArtifact, GenerateScheduleOptions, GenerateScheduleResult, ScheduleArtifact, ScheduleArtifactError, SchedulePlanningContext, compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact, scheduleArtifactPath };

package/dist/{schedule/planner.js → planning/generate.js}

@@ -3,20 +3,22 @@ import { validatePipelineConfig } from "../config/validate.js";
 import "../config.js";
 import { createRunnerLaunchPlan, runLaunchPlan } from "../runner.js";
 import { normalizeRunnerOutput } from "../runner-output.js";
-import { compileWorkflowPlan } from "../workflow-planner.js";
-import { loadBacklogPlanningContext } from "./backlog-context.js";
-import { baselineScheduleArtifact } from "./baseline.js";
-import { addGeneratedImplementationCoverage } from "./passes/coverage.js";
-import { canonicalizeGeneratedScheduleIds } from "./passes/ids.js";
-import { SCHEDULE_PASS_ORDER } from "./passes/index.js";
-import { applyNodeCatalogModelFallbacks } from "./passes/models.js";
-import { namespaceScheduleWorkflows } from "./passes/references.js";
-import { plannerPrompt, plannerRepairPrompt } from "./prompts.js";
+import { loadBacklogPlanningContext } from "../schedule/backlog-context.js";
+import { baselineScheduleArtifact } from "../schedule/baseline.js";
+import { dependentsByNeed, flattenNodes, hasReachableDependent } from "./graph.js";
+import { isCoverageNode, isImplementationNode } from "../schedule/scheduling-roles.js";
+import { addGeneratedImplementationCoverage } from "../schedule/passes/coverage.js";
+import { canonicalizeGeneratedScheduleIds } from "../schedule/passes/ids.js";
+import { SCHEDULE_PASS_ORDER } from "../schedule/passes/index.js";
+import { applyNodeCatalogModelFallbacks } from "../schedule/passes/models.js";
+import { namespaceScheduleWorkflows } from "../schedule/passes/references.js";
+import { plannerPrompt, plannerRepairPrompt } from "../schedule/prompts.js";
+import { compileWorkflowPlan } from "./compile.js";
 import { parseDocument, stringify } from "yaml";
 import { z } from "zod";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-//#region src/schedule/planner.ts
+//#region src/planning/generate.ts
 const SCHEDULE_KIND = "pipeline-schedule";
 const ID_RE = /^[a-z][a-z0-9-]*$/;
 const SCHEDULE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
@@ -253,9 +255,9 @@ function unsafeParallelWorktreeIssues(config, artifact) {
 }
 function workflowNodeIssues(artifact, collectIssues) {
 	return Object.entries(artifact.workflows).flatMap(([workflowId, workflow]) => {
-		const nodes = workflow.nodes.flatMap(flattenWorkflowNode);
+		const nodes = flattenWorkflowNodes(workflow.nodes);
 		return collectIssues({
-			dependentsByNeed: workflowDependentsByNeed(nodes),
+			dependentsByNeed: dependentsByNeed(nodes),
 			nodes,
 			workflowId
 		});
@@ -267,20 +269,8 @@ function isWriteCapableParallelChild(config, node) {
 	if (node.kind === "parallel") return node.nodes.some((child) => isWriteCapableParallelChild(config, child));
 	return false;
 }
-function hasDownstreamDrainMerge(nodeId, dependentsByNeed) {
-	return hasReachableDependent(nodeId, dependentsByNeed, (node) => node.kind === "builtin" && node.builtin === "drain-merge");
-}
-function hasReachableDependent(nodeId, dependentsByNeed, matches) {
-	const queue = [...dependentsByNeed.get(nodeId) ?? []];
-	const seen = /* @__PURE__ */ new Set();
-	while (queue.length > 0) {
-		const node = queue.shift();
-		if (!node || seen.has(node.id)) continue;
-		seen.add(node.id);
-		if (matches(node)) return true;
-		queue.push(...dependentsByNeed.get(node.id) ?? []);
-	}
-	return false;
+function hasDownstreamDrainMerge(nodeId, index) {
+	return hasReachableDependent(nodeId, index, (node) => node.kind === "builtin" && node.builtin === "drain-merge");
 }
 function generatedRootWorkflowIssues(artifact) {
 	const workflowIds = Object.keys(artifact.workflows);
@@ -331,15 +321,15 @@ function workUnitDependencyIssues(config, artifact, workUnits) {
 	const workUnitIds = new Set(workUnits.map((unit) => unit.id));
 	const dependenciesByUnit = new Map(workUnits.map((unit) => [unit.id, (unit.dependencies ?? []).filter((id) => workUnitIds.has(id))]));
 	return Object.entries(artifact.workflows).flatMap(([workflowId, workflow]) => {
-		const nodes = workflow.nodes.flatMap(flattenWorkflowNode);
-		const dependentsByNeed = workflowDependentsByNeed(nodes);
+		const nodes = flattenWorkflowNodes(workflow.nodes);
+		const index = dependentsByNeed(nodes);
 		const nodesByWorkUnit = nodesByAssignedWorkUnit(nodes);
 		return nodes.filter((node) => isImplementationNode(config, node)).flatMap((node) => {
 			const dependentId = node.task_context?.id;
 			if (!dependentId) return [];
 			return (dependenciesByUnit.get(dependentId) ?? []).flatMap((prerequisiteId) => {
 				const prerequisiteNodes = nodesByWorkUnit.get(prerequisiteId) ?? [];
-				return prerequisiteNodes.some((source) => hasPathToNode(source.id, node.id, dependentsByNeed)) ? [] : [`work unit dependency edge missing in '${workflowId}': '${dependentId}' node '${node.id}' must depend on prerequisite '${prerequisiteId}' nodes ${prerequisiteNodes.map((prerequisite) => `'${prerequisite.id}'`).join(", ")}`];
+				return prerequisiteNodes.some((source) => hasReachableDependent(source.id, index, (candidate) => candidate.id === node.id)) ? [] : [`work unit dependency edge missing in '${workflowId}': '${dependentId}' node '${node.id}' must depend on prerequisite '${prerequisiteId}' nodes ${prerequisiteNodes.map((prerequisite) => `'${prerequisite.id}'`).join(", ")}`];
 			});
 		});
 	});
@@ -355,9 +345,6 @@ function nodesByAssignedWorkUnit(nodes) {
 	}
 	return grouped;
 }
-function hasPathToNode(sourceId, targetId, dependentsByNeed) {
-	return hasReachableDependent(sourceId, dependentsByNeed, (node) => node.id === targetId);
-}
 function unsupportedGeneratedBuiltinIssues(artifact) {
 	const allowed = new Set(SCHEDULE_BUILTINS);
 	return allWorkflowNodes(artifact.workflows).flatMap((node) => {
@@ -369,33 +356,14 @@ function unsupportedGeneratedBuiltinIssues(artifact) {
 function implementationCoverageIssues(config, artifact) {
 	return workflowNodeIssues(artifact, ({ dependentsByNeed, nodes, workflowId }) => nodes.filter((node) => isImplementationNode(config, node)).filter((node) => !hasDownstreamCoverage(config, node.id, dependentsByNeed)).map((node) => `implementation node '${workflowId}.${node.id}' is without downstream verification or review`));
 }
-function isImplementationNode(config, node) {
-	return hasSchedulingRole(config, node, "implementation");
-}
-function workflowDependentsByNeed(nodes) {
-	const dependentsByNeed = /* @__PURE__ */ new Map();
-	for (const node of nodes) for (const need of node.needs ?? []) {
-		const dependents = dependentsByNeed.get(need) ?? [];
-		dependents.push(node);
-		dependentsByNeed.set(need, dependents);
-	}
-	return dependentsByNeed;
-}
-function hasDownstreamCoverage(config, nodeId, dependentsByNeed) {
-	return hasReachableDependent(nodeId, dependentsByNeed, (node) => isCoverageNode(config, node));
-}
-function isCoverageNode(config, node) {
-	return hasSchedulingRole(config, node, "coverage");
-}
-function hasSchedulingRole(config, node, role) {
-	if (node.kind !== "agent") return false;
-	return config.profiles[node.profile]?.scheduling_roles?.includes(role) ?? false;
+function hasDownstreamCoverage(config, nodeId, index) {
+	return hasReachableDependent(nodeId, index, (node) => isCoverageNode(config, node));
 }
 function allWorkflowNodes(workflows) {
-	return Object.values(workflows).flatMap((workflow) => workflow.nodes.flatMap(flattenWorkflowNode));
+	return Object.values(workflows).flatMap((workflow) => flattenWorkflowNodes(workflow.nodes));
 }
-function flattenWorkflowNode(node) {
-	return node.kind === "parallel" ? [node, ...node.nodes.flatMap(flattenWorkflowNode)] : [node];
+function flattenWorkflowNodes(nodes) {
+	return flattenNodes(nodes, (node) => node.kind === "parallel" ? node.nodes : void 0);
 }
 //#endregion
 export { ScheduleArtifactError, compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact, scheduleArtifactPath };

package/dist/planning/graph.js

@@ -0,0 +1,138 @@
+//#region src/planning/graph.ts
+/**
+* Depth-first flatten of a node tree into a flat list (parents before
+* children), using the caller-supplied accessor to descend into nested
+* containers (e.g. parallel children). Nodes without children are returned
+* as-is.
+*/
+function flattenNodes(nodes, childrenOf) {
+	return nodes.flatMap((node) => {
+		const children = childrenOf(node);
+		return children && children.length > 0 ? [node, ...flattenNodes(children, childrenOf)] : [node];
+	});
+}
+/**
+* Build an index mapping each `need` id to the (flat) nodes that declare it as a
+* dependency. The input is expected to already be flattened by the caller so
+* that the resulting index spans the whole graph.
+*/
+function dependentsByNeed(nodes) {
+	const index = /* @__PURE__ */ new Map();
+	for (const node of nodes) for (const need of node.needs ?? []) {
+		const dependents = index.get(need) ?? [];
+		dependents.push(node);
+		index.set(need, dependents);
+	}
+	return index;
+}
+/**
+* Breadth-first search over the dependents index to determine whether any node
+* transitively reachable downstream of `nodeId` satisfies `matches`. Cycle-safe
+* via a visited set.
+*/
+function hasReachableDependent(nodeId, index, matches) {
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [...index.get(nodeId) ?? []];
+	while (queue.length > 0) {
+		const node = queue.shift();
+		if (!node || visited.has(node.id)) continue;
+		visited.add(node.id);
+		if (matches(node)) return true;
+		queue.push(...index.get(node.id) ?? []);
+	}
+	return false;
+}
+/**
+* Recursively find a node by id within a node tree, descending into children
+* via the caller-supplied accessor. Returns `undefined` when absent.
+*/
+function findNode(nodes, nodeId, childrenOf) {
+	for (const node of nodes) {
+		if (node.id === nodeId) return node;
+		const child = findNode(childrenOf(node) ?? [], nodeId, childrenOf);
+		if (child) return child;
+	}
+}
+/**
+* Find all dependency cycles in a flat node list using an iterative DFS over the
+* dependents-by-need graph. Each cycle is returned once (canonicalized by its
+* member set) as the ordered list of node ids forming the loop. Only `needs`
+* that reference declared nodes participate, so callers can pass the full flat
+* node set without pre-filtering missing dependencies.
+*
+* The traversal is iterative (an explicit frame stack) rather than recursive so
+* that deep generated workflow chains cannot overflow the call stack.
+*/
+function findDependencyCycles(nodes) {
+	const nodeIds = new Set(nodes.map((node) => node.id));
+	const index = dependentsByNeed(nodes);
+	const adjacency = /* @__PURE__ */ new Map();
+	for (const node of nodes) adjacency.set(node.id, (index.get(node.id) ?? []).map((dependent) => dependent.id).filter((id) => nodeIds.has(id)));
+	const state = /* @__PURE__ */ new Map();
+	const path = [];
+	const pathIndex = /* @__PURE__ */ new Map();
+	const cycles = [];
+	const cycleKeys = /* @__PURE__ */ new Set();
+	for (const node of nodes) {
+		if (state.has(node.id)) continue;
+		visitForCycles(node.id, {
+			adjacency,
+			cycleKeys,
+			cycles,
+			path,
+			pathIndex,
+			state
+		});
+	}
+	return cycles;
+}
+function visitForCycles(startId, visitState) {
+	const frames = [{
+		index: 0,
+		nodeId: startId
+	}];
+	markVisiting(startId, visitState);
+	while (frames.length > 0) {
+		const frame = frames.at(-1);
+		if (!frame) return;
+		const dependentId = (visitState.adjacency.get(frame.nodeId) ?? [])[frame.index];
+		if (!dependentId) {
+			markDone(frame.nodeId, visitState);
+			frames.pop();
+			continue;
+		}
+		frame.index += 1;
+		const dependentState = visitState.state.get(dependentId);
+		if (dependentState === "visiting") {
+			recordCycle(dependentId, visitState);
+			continue;
+		}
+		if (dependentState === "done") continue;
+		markVisiting(dependentId, visitState);
+		frames.push({
+			index: 0,
+			nodeId: dependentId
+		});
+	}
+}
+function markVisiting(nodeId, visitState) {
+	visitState.state.set(nodeId, "visiting");
+	visitState.pathIndex.set(nodeId, visitState.path.length);
+	visitState.path.push(nodeId);
+}
+function markDone(nodeId, visitState) {
+	visitState.state.set(nodeId, "done");
+	visitState.pathIndex.delete(nodeId);
+	visitState.path.pop();
+}
+function recordCycle(nodeId, visitState) {
+	const startIndex = visitState.pathIndex.get(nodeId);
+	if (startIndex === void 0) return;
+	const cycle = visitState.path.slice(startIndex);
+	const key = [...cycle].sort().join("\0");
+	if (visitState.cycleKeys.has(key)) return;
+	visitState.cycleKeys.add(key);
+	visitState.cycles.push(cycle);
+}
+//#endregion
+export { dependentsByNeed, findDependencyCycles, findNode, flattenNodes, hasReachableDependent };

package/dist/runner-command/lifecycle-context.js

@@ -1,9 +1,8 @@
-import { parseRunnerCommandPayload, resolveRunnerEventSinkAuthToken } from "../runner-command-contract.js";
 import { PIPELINE_CONFIG_PATH, PROFILES_CONFIG_PATH, RUNNERS_CONFIG_PATH } from "../config/defaults.js";
 import { loadPipelineConfig, parsePipelineConfigParts } from "../config/load.js";
 import "../config.js";
-import { compileScheduleArtifact, parseScheduleArtifact } from "../schedule/planner.js";
-import "../schedule-planner.js";
+import { compileScheduleArtifact, parseScheduleArtifact } from "../planning/generate.js";
+import { parseRunnerCommandPayload, resolveRunnerEventSinkAuthToken } from "../runner-command-contract.js";
 import { prepareRunnerGitWorkspace } from "../run-state/git-refs.js";
 import { createRunnerEventSink } from "../runner-event-sink.js";
 import { initialNodeStateStore } from "../runtime/node-state-store.js";

package/dist/runner-command/run.js

@@ -1,9 +1,8 @@
 import { readRunnerTaskDescriptor } from "./task-descriptor.js";
-import { RunnerCommandPayloadValidationError, parseRunnerCommandPayload, resolveRunnerEventSinkAuthToken } from "../runner-command-contract.js";
 import { loadPipelineConfig } from "../config/load.js";
 import "../config.js";
-import { compileScheduleArtifact, parseScheduleArtifact } from "../schedule/planner.js";
-import "../schedule-planner.js";
+import { compileScheduleArtifact, parseScheduleArtifact } from "../planning/generate.js";
+import { RunnerCommandPayloadValidationError, parseRunnerCommandPayload, resolveRunnerEventSinkAuthToken } from "../runner-command-contract.js";
 import { commitAndPushNodeRef, mergeDependencyRefs, prepareRunnerGitWorkspace } from "../run-state/git-refs.js";
 import { createRunnerEventSink } from "../runner-event-sink.js";
 import { findPlannedNode } from "../planned-node.js";

package/dist/runner-command-contract.d.ts

@@ -43,8 +43,8 @@ declare const runnerDeliverySchema: z.ZodObject<{
 declare const mokaSubmissionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   kind: z.ZodLiteral<"graph">;
   mode: z.ZodEnum<{
-    quick: "quick";
     full: "full";
+    quick: "quick";
   }>;
 }, z.core.$strict>, z.ZodObject<{
   argv: z.ZodArray<z.ZodString>;
@@ -104,8 +104,8 @@ declare const runnerCommandPayloadSchema: z.ZodObject<{
   submission: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"graph">;
     mode: z.ZodEnum<{
-      quick: "quick";
       full: "full";
+      quick: "quick";
     }>;
   }, z.core.$strict>, z.ZodObject<{
     argv: z.ZodArray<z.ZodString>;