@oisincoveney/pipeline 2.0.0 → 2.1.0

package/dist/schedule/backlog-context.js

@@ -0,0 +1,114 @@
+import { extractTicketIds } from "../task-ref.js";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { Graph, alg } from "@dagrejs/graphlib";
+import matter from "gray-matter";
+//#region src/schedule/backlog-context.ts
+const DESCRIPTION_SECTION_RE = /## Description\s+([\s\S]*?)(?=\n## |\s*$)/;
+const ACCEPTANCE_SECTION_RE = /## Acceptance Criteria\s+([\s\S]*?)(?=\n## |\s*$)/;
+const ACCEPTANCE_ITEM_RE = /^\s*-\s*\[[ xX]\]\s*#?([\w.-]+)\s+(.+)$/;
+const LINE_RE = /\r?\n/;
+function loadBacklogPlanningContext(task, worktreePath) {
+	const ticketIds = extractTicketIds(task);
+	if (ticketIds.length === 0) return {
+		parentWorkUnits: [],
+		workUnits: []
+	};
+	const tasks = readBacklogTasks(worktreePath);
+	const tasksById = new Map(tasks.map((taskFile) => [taskFile.id, taskFile]));
+	const taskGraph = backlogTaskGraph(tasks);
+	const parentWorkUnits = [];
+	const workUnits = [];
+	const parentIds = /* @__PURE__ */ new Set();
+	const workUnitIds = /* @__PURE__ */ new Set();
+	for (const ticketId of ticketIds) {
+		const taskFile = tasksById.get(ticketId);
+		if (!taskFile) continue;
+		const descendants = descendantBacklogTasks(ticketId, taskGraph);
+		if (descendants.length === 0) {
+			addUniqueWorkUnit(taskFile.workUnit, workUnits, workUnitIds);
+			continue;
+		}
+		addUniqueWorkUnit(taskFile.workUnit, parentWorkUnits, parentIds);
+		for (const descendant of descendants) addUniqueWorkUnit(descendant.workUnit, workUnits, workUnitIds);
+	}
+	return {
+		parentWorkUnits,
+		workUnits
+	};
+}
+function backlogTaskGraph(tasks) {
+	const graph = new Graph();
+	const sortedTasks = [...tasks].sort(compareBacklogTaskIds);
+	for (const task of sortedTasks) graph.setNode(task.id, task);
+	for (const task of sortedTasks) if (task.parentTaskId && graph.hasNode(task.parentTaskId)) graph.setEdge(task.parentTaskId, task.id);
+	return graph;
+}
+function descendantBacklogTasks(taskId, taskGraph) {
+	if (!taskGraph.hasNode(taskId)) return [];
+	return alg.preorder(taskGraph, taskId).slice(1).map((id) => taskGraph.node(id)).filter((task) => Boolean(task));
+}
+function compareBacklogTaskIds(a, b) {
+	return a.id.localeCompare(b.id, void 0, { numeric: true });
+}
+function addUniqueWorkUnit(workUnit, target, seen) {
+	if (seen.has(workUnit.id)) return;
+	seen.add(workUnit.id);
+	target.push(workUnit);
+}
+function readBacklogTasks(worktreePath) {
+	const tasksDir = join(worktreePath, "backlog", "tasks");
+	if (!existsSync(tasksDir)) return [];
+	return readdirSync(tasksDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).flatMap((entry) => readBacklogTaskFile(join(tasksDir, entry.name)));
+}
+function readBacklogTaskFile(path) {
+	const parsed = matter(readFileSync(path, "utf8"));
+	const id = stringFrontmatter(parsed.data.id);
+	if (!id) return [];
+	return [{
+		id,
+		parentTaskId: stringFrontmatter(parsed.data.parent_task_id),
+		workUnit: {
+			acceptance_criteria: acceptanceCriteriaFromMarkdown(parsed.content),
+			...optionalStringArrayField("dependencies", stringArrayFrontmatter(parsed.data.dependencies)),
+			...optionalStringField("description", descriptionFromMarkdown(parsed.content)),
+			id,
+			...optionalStringField("title", stringFrontmatter(parsed.data.title))
+		}
+	}];
+}
+function stringFrontmatter(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function stringArrayFrontmatter(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+}
+function optionalStringField(key, value) {
+	return value ? { [key]: value } : {};
+}
+function optionalStringArrayField(key, value) {
+	return value.length > 0 ? { [key]: value } : {};
+}
+function descriptionFromMarkdown(content) {
+	const marked = betweenMarkers(content, "<!-- SECTION:DESCRIPTION:BEGIN -->", "<!-- SECTION:DESCRIPTION:END -->");
+	if (marked) return marked;
+	return cleanupMarkdownSection(content.match(DESCRIPTION_SECTION_RE)?.[1]);
+}
+function acceptanceCriteriaFromMarkdown(content) {
+	return (betweenMarkers(content, "<!-- AC:BEGIN -->", "<!-- AC:END -->") ?? content.match(ACCEPTANCE_SECTION_RE)?.[1] ?? "").split(LINE_RE).map((line) => line.match(ACCEPTANCE_ITEM_RE)).filter((match) => Boolean(match)).map((match) => ({
+		id: match[1] ?? "",
+		text: (match[2] ?? "").trim()
+	})).filter((criterion) => criterion.id && criterion.text);
+}
+function betweenMarkers(content, start, end) {
+	const startIndex = content.indexOf(start);
+	const endIndex = content.indexOf(end);
+	if (startIndex === -1 || endIndex === -1 || endIndex <= startIndex) return;
+	return cleanupMarkdownSection(content.slice(startIndex + start.length, endIndex));
+}
+function cleanupMarkdownSection(value) {
+	return value?.split(LINE_RE).map((line) => line.trim()).filter(Boolean).join("\n") || void 0;
+}
+//#endregion
+export { loadBacklogPlanningContext };

package/dist/schedule/baseline.js

@@ -0,0 +1,267 @@
+//#region src/schedule/baseline.ts
+const SCHEDULE_KIND = "pipeline-schedule";
+function baselineScheduleArtifact(input) {
+	const scheduleId = input.runId ?? defaultScheduleId(input.generatedAt);
+	const baseline = baselineWorkflows(input.baseline, input.config);
+	return {
+		generated_at: input.generatedAt.toISOString(),
+		kind: SCHEDULE_KIND,
+		root_workflow: baseline.rootWorkflow,
+		schedule_id: scheduleId,
+		source_entrypoint: input.entrypointId,
+		task: input.task,
+		version: 1,
+		workflows: baseline.workflows
+	};
+}
+function baselineWorkflows(baseline, _config) {
+	if (baseline === "quick") return {
+		rootWorkflow: "root",
+		workflows: quickBaselineWorkflow()
+	};
+	return {
+		rootWorkflow: "root",
+		workflows: executeBaselineWorkflow()
+	};
+}
+function quickBaselineWorkflow() {
+	return { root: {
+		description: "Compact generated quick schedule seed.",
+		nodes: [
+			{
+				id: "backlog-intake",
+				kind: "agent",
+				profile: "moka-researcher"
+			},
+			{
+				id: "red-tests",
+				kind: "agent",
+				needs: ["backlog-intake"],
+				profile: "moka-test-writer"
+			},
+			{
+				id: "implement",
+				kind: "agent",
+				needs: ["red-tests"],
+				profile: "moka-code-writer"
+			},
+			{
+				builtin: "test",
+				id: "mechanical-tests",
+				kind: "builtin",
+				needs: ["implement"]
+			},
+			{
+				builtin: "typecheck",
+				id: "mechanical-typecheck",
+				kind: "builtin",
+				needs: ["implement"]
+			},
+			{
+				gates: [
+					{
+						builtin: "typecheck",
+						id: "verify-typecheck",
+						kind: "builtin"
+					},
+					{
+						builtin: "test",
+						id: "verify-tests",
+						kind: "builtin"
+					},
+					{
+						builtin: "lint",
+						id: "verify-lint",
+						kind: "builtin"
+					},
+					{
+						builtin: "fallow",
+						id: "verify-fallow",
+						kind: "builtin"
+					},
+					{
+						kind: "verdict",
+						id: "verify-verdict",
+						target: "stdout"
+					}
+				],
+				id: "verify",
+				kind: "agent",
+				needs: ["mechanical-tests", "mechanical-typecheck"],
+				profile: "moka-verifier"
+			}
+		]
+	} };
+}
+function executeBaselineWorkflow() {
+	return { root: {
+		description: "Full generated execute schedule seed.",
+		nodes: [
+			{
+				id: "backlog-intake",
+				kind: "agent",
+				profile: "moka-researcher"
+			},
+			{
+				id: "research",
+				kind: "agent",
+				needs: ["backlog-intake"],
+				profile: "moka-researcher"
+			},
+			{
+				gates: [{
+					changed_files: {
+						allow: [
+							"**/*.test.*",
+							"**/*.spec.*",
+							"**/*_test.*",
+							"**/__tests__/**",
+							"test/**",
+							"tests/**",
+							"**/*.snap"
+						],
+						require_any: [
+							"**/*.test.*",
+							"**/*.spec.*",
+							"**/*_test.*",
+							"**/__tests__/**",
+							"test/**",
+							"tests/**"
+						]
+					},
+					id: "red-test-file-policy",
+					kind: "changed_files"
+				}],
+				id: "red-tests",
+				kind: "agent",
+				needs: ["research"],
+				profile: "moka-test-writer"
+			},
+			{
+				id: "green-implementation",
+				kind: "agent",
+				needs: ["red-tests"],
+				profile: "moka-code-writer"
+			},
+			{
+				builtin: "test",
+				id: "mechanical-green-tests",
+				kind: "builtin",
+				needs: ["green-implementation"]
+			},
+			{
+				builtin: "typecheck",
+				id: "mechanical-green-typecheck",
+				kind: "builtin",
+				needs: ["green-implementation"]
+			},
+			{
+				builtin: "lint",
+				id: "mechanical-green-lint",
+				kind: "builtin",
+				needs: ["green-implementation"]
+			},
+			{
+				builtin: "fallow",
+				id: "mechanical-green-fallow",
+				kind: "builtin",
+				needs: ["green-implementation"]
+			},
+			{
+				gates: [{
+					id: "acceptance-coverage",
+					kind: "acceptance",
+					required: false,
+					target: "stdout"
+				}, {
+					id: "acceptance-verdict",
+					kind: "verdict",
+					target: "stdout"
+				}],
+				id: "acceptance-review",
+				kind: "agent",
+				needs: [
+					"mechanical-green-tests",
+					"mechanical-green-typecheck",
+					"mechanical-green-lint",
+					"mechanical-green-fallow"
+				],
+				profile: "moka-acceptance-reviewer"
+			},
+			{
+				gates: [
+					{
+						builtin: "typecheck",
+						id: "verify-typecheck",
+						kind: "builtin"
+					},
+					{
+						builtin: "test",
+						id: "verify-tests",
+						kind: "builtin"
+					},
+					{
+						builtin: "lint",
+						id: "verify-lint",
+						kind: "builtin"
+					},
+					{
+						builtin: "fallow",
+						id: "verify-fallow",
+						kind: "builtin"
+					},
+					{
+						builtin: "semgrep",
+						id: "verify-semgrep",
+						kind: "builtin"
+					},
+					{
+						builtin: "duplication",
+						id: "verify-duplication",
+						kind: "builtin"
+					},
+					{
+						id: "verify-verdict",
+						kind: "verdict",
+						target: "stdout"
+					}
+				],
+				id: "verification",
+				kind: "agent",
+				needs: [
+					"mechanical-green-tests",
+					"mechanical-green-typecheck",
+					"mechanical-green-lint",
+					"mechanical-green-fallow"
+				],
+				profile: "moka-verifier"
+			},
+			{
+				id: "code-quality-review",
+				kind: "agent",
+				needs: [
+					"mechanical-green-tests",
+					"mechanical-green-typecheck",
+					"mechanical-green-lint",
+					"mechanical-green-fallow"
+				],
+				profile: "moka-thermo-nuclear-reviewer"
+			},
+			{
+				id: "learn",
+				kind: "agent",
+				needs: [
+					"acceptance-review",
+					"verification",
+					"code-quality-review"
+				],
+				profile: "moka-learner"
+			}
+		]
+	} };
+}
+function defaultScheduleId(date) {
+	return `run-${date.toISOString().replaceAll(/[-:.TZ]/g, "").slice(0, 14)}`;
+}
+//#endregion
+export { baselineScheduleArtifact };