@vercel/factory 0.0.9 → 0.0.11

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { a as repositoryIdsSchema, c as SCHEMA_VERSION, d as schemaVersionSchema, f as usdSchema, i as repositoryIdSchema, l as isoDateTimeSchema, n as factoryIdSchema, o as signalIdSchema, p as vocabularySchema, r as receiptIdSchema, s as taskIdSchema, t as changeIdSchema, u as replyToSchema } from "./id-DwCihQr4.mjs";
 import { a as findingCategorySchema, c as findingSchema, d as findingVerificationSchema, i as requiresApproval, l as findingVerificationLevelSchema, n as approvalRuleSchema, o as findingFingerprint, r as defaultApprovalPolicy, s as findingPrioritySchema, t as approvalPolicySchema, u as findingVerificationMethodSchema } from "./approval-DdvEKLiE.mjs";
 import { n as RecordNotFoundError, r as VersionConflictError, t as RecordExistsError } from "./driver-Bbd25rNM.mjs";
-import { a as taskKindSchema, c as taskSchema, d as changeSchema, f as changeStateSchema, g as dispatchTask, h as DispatchRefusedError, i as taskDevboxSchema, l as taskStateSchema, m as DEFAULT_MAX_LAUNCH_ATTEMPTS, n as standardTaskKinds, o as taskOriginSchema, p as levelSchema, r as taskApprovalSchema, s as taskQuestionSchema, t as harnessSchema, u as changeEvidenceSchema } from "./task-DMHuvBI0.mjs";
+import { _ as taskSchema, a as DEFAULT_MAX_LAUNCH_ATTEMPTS, c as coordinationRepositoryIdsSchema, d as taskApprovalSchema, f as taskDevboxSchema, g as taskQuestionSchema, h as taskOriginSchema, i as levelSchema, l as harnessSchema, m as taskKindSchema, n as changeSchema, o as DispatchRefusedError, p as taskExecutionRepositoryIdsSchema, r as changeStateSchema, s as dispatchTask, t as changeEvidenceSchema, u as standardTaskKinds, v as taskStateSchema } from "./change-BPYhWKuL.mjs";
 import { a as repositorySlugSchema, i as repositorySchema, n as factoryConfigRepositorySchema, r as factoryConfigSchema, t as defineFactory } from "./factory-config-ifd3JxiU.mjs";
 import { z } from "zod";
 import { createHash, randomUUID } from "node:crypto";
@@ -56,6 +56,238 @@ async function adoptPullRequest(stores, input) {
 	});
 }
 //#endregion
+//#region src/coordination.ts
+/** Create one non-executable parent and one independently executable child per repository. */
+async function createCoordination(stores, input) {
+	const repositoryIds = [...new Set(input.repositoryIds)];
+	if (repositoryIds.length < 2) throw new Error("coordination requires at least two distinct repositories");
+	const parent = await stores.tasks.create({
+		repositoryIds,
+		kind: "coordination",
+		origin: { signalId: input.signalId },
+		replyTo: input.replyTo
+	});
+	return {
+		parent: await stores.tasks.transition(parent.id, "running", { reason: "repository-scoped child tasks created" }),
+		children: await Promise.all(repositoryIds.map((repositoryId) => stores.tasks.create({
+			repositoryIds: [repositoryId],
+			kind: "code_change",
+			origin: { parentTaskId: parent.id },
+			replyTo: input.replyTo
+		})))
+	};
+}
+/** Reconcile a coordination parent from its direct children without ever dispatching the parent. */
+async function reconcileCoordination(stores, parentTaskId, options) {
+	const parent = await stores.tasks.get(parentTaskId);
+	if (parent === null) throw new RecordNotFoundError("tasks", parentTaskId);
+	if (parent.kind !== "coordination") throw new Error(`task ${parentTaskId} is ${parent.kind}, not coordination`);
+	const children = (await stores.tasks.list()).filter((task) => task.origin.parentTaskId === parentTaskId);
+	if (children.length !== parent.repositoryIds.length) return {
+		status: "pending",
+		parent,
+		children
+	};
+	if (parent.state === "succeeded" || parent.state === "failed") return {
+		status: parent.state,
+		transitioned: false,
+		parent,
+		children
+	};
+	if (children.some((child) => child.state === "failed" || child.state === "cancelled")) {
+		await options.present({
+			status: "failed",
+			parent,
+			children
+		});
+		return {
+			status: "failed",
+			transitioned: true,
+			parent: await stores.tasks.transition(parent.id, "failed", { reason: "one or more repository tasks failed" }),
+			children
+		};
+	}
+	if (!children.every((child) => child.state === "succeeded")) return {
+		status: "pending",
+		parent,
+		children
+	};
+	await options.present({
+		status: "succeeded",
+		parent,
+		children
+	});
+	await stores.tasks.transition(parent.id, "verifying", { reason: "all repository tasks succeeded" });
+	return {
+		status: "succeeded",
+		transitioned: true,
+		parent: await stores.tasks.transition(parent.id, "succeeded", { reason: "aggregate multi-repository handoff is ready" }),
+		children
+	};
+}
+//#endregion
+//#region src/metrics.ts
+const bucketTable = {
+	low: {
+		low: "review",
+		medium: "stamp",
+		high: "stamp"
+	},
+	medium: {
+		low: "review",
+		medium: "review",
+		high: "stamp"
+	},
+	high: {
+		low: "blocked",
+		medium: "review",
+		high: "review"
+	}
+};
+function reviewBucket(risk, confidence) {
+	return bucketTable[risk][confidence];
+}
+function collectFacts(rows) {
+	const byChange = /* @__PURE__ */ new Map();
+	for (const receipt of rows.receipts) {
+		if (receipt.kind !== "change" || receipt.changeId === void 0) continue;
+		const list = byChange.get(receipt.changeId) ?? [];
+		list.push(receipt);
+		byChange.set(receipt.changeId, list);
+	}
+	const at = (receipts, state) => {
+		const found = receipts?.find((receipt) => receipt.state === state);
+		return found === void 0 ? null : Date.parse(found.recordedAt);
+	};
+	return rows.changes.map((change) => {
+		const receipts = byChange.get(change.id);
+		const requiredState = change.risk === "high" ? "rolled_out" : "deployed";
+		return {
+			change,
+			readyAt: at(receipts, "ready"),
+			mergedAt: at(receipts, "merged"),
+			reachedAt: at(receipts, requiredState),
+			rolledBackAt: at(receipts, "rolled_back")
+		};
+	});
+}
+/** True for a change a human saw as ready and then closed unmerged. */
+function closedAfterReady(facts) {
+	return facts.change.state === "closed" && (facts.readyAt !== null || facts.change.decidedBy !== void 0);
+}
+function median(values) {
+	if (values.length === 0) return null;
+	const sorted = [...values].sort((a, b) => a - b);
+	const mid = Math.floor(sorted.length / 2);
+	return sorted.length % 2 === 1 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+/**
+* The six product metrics from ledger rows alone. One rule governs them: a
+* change counts only after a human merged it and it stayed. Activity that
+* never landed is not a result. Compute over rows already filtered to the
+* period and repositories you are reporting on.
+*/
+function computeLedgerMetrics(rows, options = {}) {
+	const now = (options.now ?? /* @__PURE__ */ new Date()).getTime();
+	const holdMs = (options.holdDays ?? 7) * 24 * 60 * 60 * 1e3;
+	const facts = collectFacts(rows);
+	let landed = 0;
+	let provisional = 0;
+	let rolledBack = 0;
+	let closedAfterReadyCount = 0;
+	let closedInVerification = 0;
+	const landedChangeIds = /* @__PURE__ */ new Set();
+	for (const fact of facts) {
+		const { change } = fact;
+		if (fact.rolledBackAt !== null) {
+			rolledBack += 1;
+			continue;
+		}
+		if (change.state === "closed") {
+			if (closedAfterReady(fact)) closedAfterReadyCount += 1;
+			else closedInVerification += 1;
+			continue;
+		}
+		if (change.decidedBy !== void 0 && fact.reachedAt !== null) {
+			landed += 1;
+			landedChangeIds.add(change.id);
+			if (now - fact.reachedAt < holdMs) provisional += 1;
+		}
+	}
+	const stickDenominator = landed + rolledBack + closedAfterReadyCount;
+	const humanTimes = {
+		stamp: [],
+		review: []
+	};
+	for (const fact of facts) {
+		if (fact.readyAt === null || fact.mergedAt === null) continue;
+		const bucket = reviewBucket(fact.change.risk, fact.change.confidence);
+		if (bucket === "blocked") continue;
+		humanTimes[bucket].push(fact.mergedAt - fact.readyAt);
+	}
+	let settledOverLanded = 0;
+	let sawSettledCost = false;
+	for (const task of rows.tasks) {
+		if (task.settledUsd === void 0) continue;
+		if (task.kind === "code_change" && task.changeId !== void 0 && landedChangeIds.has(task.changeId)) {
+			settledOverLanded += task.settledUsd;
+			sawSettledCost = true;
+		}
+	}
+	const rejectedSignals = rows.signals.filter((signal) => signal.outcome !== "pending" && signal.outcome !== "accepted").length;
+	return {
+		landed,
+		provisional,
+		stickRate: stickDenominator === 0 ? null : landed / stickDenominator,
+		stampedClean: null,
+		humanTimeMs: {
+			stamp: median(humanTimes.stamp),
+			review: median(humanTimes.review)
+		},
+		costPerLandedUsd: sawSettledCost && landed > 0 ? settledOverLanded / landed : null,
+		filtered: rejectedSignals + closedInVerification
+	};
+}
+const openChangeStates = /* @__PURE__ */ new Set(["verifying", "ready"]);
+/**
+* Green, yellow, or red from rows, never from a model. Budget and onboarding
+* signals are not evaluated yet: budgets do not settle and onboarding
+* investigations are not recorded, so those spec rules have no rows to read.
+*/
+function computeRepositoryHealth(rows, options = {}) {
+	const now = (options.now ?? /* @__PURE__ */ new Date()).getTime();
+	const dayMs = 864e5;
+	const red = [];
+	const yellow = [];
+	for (const receipt of rows.receipts) {
+		if (now - Date.parse(receipt.recordedAt) >= dayMs) continue;
+		if (receipt.state === "rolled_back") red.push(`rollback in the last 24h (${receipt.receiptId})`);
+		if (receipt.state === "cancelled" && receipt.reason?.toLowerCase().includes("kill")) red.push(`kill in the last 24h (${receipt.receiptId})`);
+	}
+	const openQuestions = rows.tasks.filter((task) => task.kind === "question" && task.state === "needs_human").length;
+	if (openQuestions > 0) yellow.push(`${openQuestions} open question(s)`);
+	const needsHuman = rows.tasks.filter((task) => task.kind !== "question" && task.state === "needs_human").length;
+	if (needsHuman > 0) yellow.push(`${needsHuman} task(s) waiting on a human`);
+	const blocked = rows.changes.filter((change) => openChangeStates.has(change.state) && reviewBucket(change.risk, change.confidence) === "blocked").length;
+	if (blocked > 0) yellow.push(`${blocked} change(s) in the blocked bucket`);
+	if (options.maxOpenChanges !== void 0) {
+		const open = rows.changes.filter((change) => openChangeStates.has(change.state)).length;
+		if (open >= options.maxOpenChanges) yellow.push(`open changes at the cap (${open}/${options.maxOpenChanges})`);
+	}
+	if (red.length > 0) return {
+		color: "red",
+		reasons: red
+	};
+	if (yellow.length > 0) return {
+		color: "yellow",
+		reasons: yellow
+	};
+	return {
+		color: "green",
+		reasons: []
+	};
+}
+//#endregion
 //#region src/schema/budget.ts
 const budgetMonthSchema = z.string().regex(/^\d{4}-(0[1-9]|1[0-2])$/);
 const budgetSchema = z.strictObject({
@@ -86,6 +318,7 @@ const standardReceiptStates = [
 	"needs_human",
 	"cancelled",
 	"settled",
+	"ready",
 	"merged",
 	"deployed",
 	"rolled_out",
@@ -438,6 +671,18 @@ var ApprovalError = class extends Error {
 		this.reason = reason;
 	}
 };
+var ChangeAssociationError = class extends Error {
+	taskId;
+	repositoryId;
+	reason;
+	constructor(taskId, repositoryId, reason) {
+		super(`change for task "${taskId}" refused: ${reason}`);
+		this.name = "ChangeAssociationError";
+		this.taskId = taskId;
+		this.repositoryId = repositoryId;
+		this.reason = reason;
+	}
+};
 const taskReceiptStates = {
 	running: "dispatched",
 	succeeded: "succeeded",
@@ -446,6 +691,7 @@ const taskReceiptStates = {
 	cancelled: "cancelled"
 };
 const changeReceiptStates = {
+	ready: "ready",
 	merged: "merged",
 	deployed: "deployed",
 	rolled_out: "rolled_out",
@@ -688,6 +934,13 @@ function createStores(options) {
 					createdAt: timestamp,
 					updatedAt: timestamp
 				});
+				await mustRead("repositories", change.repositoryId, repositorySchema);
+				if (change.taskId !== void 0) {
+					const task = (await mustRead("tasks", change.taskId, taskSchema)).value;
+					if (task.kind !== "code_change") throw new ChangeAssociationError(change.taskId, change.repositoryId, "changes can only be produced by code_change tasks");
+					const taskRepositoryId = task.repositoryIds[0];
+					if (taskRepositoryId !== change.repositoryId) throw new ChangeAssociationError(change.taskId, change.repositoryId, `repository "${change.repositoryId}" does not match task repository "${taskRepositoryId}"`);
+				}
 				await driver.insert("changes", change.id, change);
 				return change;
 			},
@@ -805,6 +1058,21 @@ async function sweepQueued(stores, options) {
 	};
 	const queued = (await stores.tasks.list()).filter((task) => task.state === "queued" && task.kind !== "question").sort((a, b) => a.createdAt.localeCompare(b.createdAt));
 	for (const task of queued) {
+		if (task.kind === "coordination") {
+			result.skipped.push({
+				taskId: task.id,
+				reason: "coordination tasks are reconciled, not dispatched"
+			});
+			continue;
+		}
+		const executionRepositoryIds = taskExecutionRepositoryIdsSchema.safeParse(task.repositoryIds);
+		if (!executionRepositoryIds.success) {
+			result.skipped.push({
+				taskId: task.id,
+				reason: "task execution requires exactly one repository"
+			});
+			continue;
+		}
 		if (task.approval === "required") {
 			result.skipped.push({
 				taskId: task.id,
@@ -820,8 +1088,7 @@ async function sweepQueued(stores, options) {
 			});
 			continue;
 		}
-		const repositoryId = task.repositoryIds?.[0];
-		const repository = repositoryId === void 0 ? null : await stores.repositories.get(repositoryId);
+		const repository = await stores.repositories.get(executionRepositoryIds.data[0]);
 		if (repository === null) {
 			result.skipped.push({
 				taskId: task.id,
@@ -849,6 +1116,6 @@ async function sweepQueued(stores, options) {
 	return result;
 }
 //#endregion
-export { ApprovalError, DEFAULT_MAX_LAUNCH_ATTEMPTS, DispatchRefusedError, InvalidTransitionError, RecordExistsError, RecordNotFoundError, SCHEMA_VERSION, VersionConflictError, adoptPullRequest, approvalPolicySchema, approvalRuleSchema, assertTransition, budgetMonthSchema, budgetSchema, changeEvidenceSchema, changeIdSchema, changeInitialState, changeSchema, changeStateSchema, changeTransitions, costSchema, createInMemoryDriver, createSignalCreator, createStores, defaultApprovalPolicy, defineFactory, dispatchTask, factoryConfigRepositorySchema, factoryConfigSchema, factoryIdSchema, findingCategorySchema, findingFingerprint, findingForTask, findingPrioritySchema, findingSchema, findingVerificationLevelSchema, findingVerificationMethodSchema, findingVerificationSchema, fixBrief, harnessSchema, isTransitionAllowed, isoDateTimeSchema, legalNextStates, levelSchema, receiptIdSchema, receiptKindSchema, receiptPhaseSchema, receiptSchema, receiptStateSchema, replyToSchema, repositoryIdSchema, repositoryIdsSchema, repositorySchema, repositorySlugSchema, requiresApproval, scanBrief, schemaVersionSchema, signalIdSchema, signalInitialOutcome, signalOutcomeSchema, signalOutcomeTransitions, signalSchema, signalSourceSchema, standardReceiptKinds, standardReceiptPhases, standardReceiptStates, standardSignalSources, standardTaskKinds, sweepQueued, taskApprovalSchema, taskDevboxSchema, taskIdSchema, taskInitialState, taskKindSchema, taskOriginSchema, taskQuestionSchema, taskSchema, taskStateSchema, taskTransitions, terminalStates, usdSchema, vocabularySchema };
+export { ApprovalError, ChangeAssociationError, DEFAULT_MAX_LAUNCH_ATTEMPTS, DispatchRefusedError, InvalidTransitionError, RecordExistsError, RecordNotFoundError, SCHEMA_VERSION, VersionConflictError, adoptPullRequest, approvalPolicySchema, approvalRuleSchema, assertTransition, budgetMonthSchema, budgetSchema, changeEvidenceSchema, changeIdSchema, changeInitialState, changeSchema, changeStateSchema, changeTransitions, computeLedgerMetrics, computeRepositoryHealth, coordinationRepositoryIdsSchema, costSchema, createCoordination, createInMemoryDriver, createSignalCreator, createStores, defaultApprovalPolicy, defineFactory, dispatchTask, factoryConfigRepositorySchema, factoryConfigSchema, factoryIdSchema, findingCategorySchema, findingFingerprint, findingForTask, findingPrioritySchema, findingSchema, findingVerificationLevelSchema, findingVerificationMethodSchema, findingVerificationSchema, fixBrief, harnessSchema, isTransitionAllowed, isoDateTimeSchema, legalNextStates, levelSchema, receiptIdSchema, receiptKindSchema, receiptPhaseSchema, receiptSchema, receiptStateSchema, reconcileCoordination, replyToSchema, repositoryIdSchema, repositoryIdsSchema, repositorySchema, repositorySlugSchema, requiresApproval, reviewBucket, scanBrief, schemaVersionSchema, signalIdSchema, signalInitialOutcome, signalOutcomeSchema, signalOutcomeTransitions, signalSchema, signalSourceSchema, standardReceiptKinds, standardReceiptPhases, standardReceiptStates, standardSignalSources, standardTaskKinds, sweepQueued, taskApprovalSchema, taskDevboxSchema, taskExecutionRepositoryIdsSchema, taskIdSchema, taskInitialState, taskKindSchema, taskOriginSchema, taskQuestionSchema, taskSchema, taskStateSchema, taskTransitions, terminalStates, usdSchema, vocabularySchema };
 
 //# sourceMappingURL=index.mjs.map