@mastra/factory 0.0.0-esbuild-bundle-worker-20260807173433

package/dist/integrations/github/rules.js

@@ -0,0 +1,551 @@
+import { changeRequestTargetKey } from "./subscriptions.js";
+import { resolveFactoryGithubRule } from "../../rules/resolve.js";
+import { validateFactoryRuleDecisions } from "../../rules/validation.js";
+//#region src/integrations/github/rules.ts
+const TRUSTED_PERMISSIONS = /* @__PURE__ */ new Set(["write", "admin"]);
+const RULE_TIMEOUT_MS = 5e3;
+const FACTORY_TRIAGE_COMMENT_MARKER = "<!-- mastra-factory-triage -->";
+async function withRuleTimeout(promise) {
+	let timeout;
+	try {
+		return await Promise.race([promise, new Promise((_, reject) => {
+			timeout = setTimeout(() => reject(/* @__PURE__ */ new Error("FACTORY_RULE_TIMEOUT")), RULE_TIMEOUT_MS);
+		})]);
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
+}
+function object(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function string(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function number(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function boolean(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function actorLogins(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((actor) => {
+		const login = string(object(actor)?.login);
+		return login ? [login] : [];
+	});
+}
+function eventName(parsed) {
+	const action = string(parsed.payload.action);
+	if (parsed.event === "issues" && action === "opened") return "issueOpened";
+	if (parsed.event === "issues" && action === "edited") {
+		const changes = object(parsed.payload.changes);
+		return object(changes?.title) || object(changes?.body) ? "issueEdited" : void 0;
+	}
+	if (parsed.event === "issues" && action === "closed") return "issueClosed";
+	if (parsed.event === "issue_comment") {
+		if (object(object(parsed.payload.issue)?.pull_request)) return void 0;
+		if (action === "created") return "issueCommentCreated";
+		if (action === "edited") return "issueCommentEdited";
+		if (action === "deleted") return "issueCommentDeleted";
+	}
+	if (parsed.event === "pull_request" && action === "opened") return "pullRequestOpened";
+	if (parsed.event === "pull_request" && action === "synchronize") return "pullRequestUpdated";
+	if (parsed.event === "pull_request" && action === "closed") return boolean(object(parsed.payload.pull_request)?.merged) ? "pullRequestMerged" : "pullRequestClosed";
+	if (parsed.event === "pull_request" && action === "review_requested") return "pullRequestReviewRequested";
+}
+/**
+* Canonical source keys (`github-issue:N`, `github-pr:N`) do not identify a
+* repository, so a project linked to several repositories could bind repo A's
+* event to repo B's same-numbered card. The card's intake-stamped URL is
+* authoritative; the intake-stamped `githubRepositoryId` covers URL-less
+* cards. A card with neither signal cannot be attributed by number alone.
+*/
+function cardBelongsToRepository(item, repositoryId, repositoryFullName) {
+	const url = item.externalSource?.url;
+	if (url) {
+		const match = /^https?:\/\/[^/]+\/(.+)\/(?:issues|pull)\/\d+(?:[/?#]|$)/.exec(url);
+		if (match && match[1] === repositoryFullName) return true;
+	}
+	return item.metadata?.githubRepositoryId === repositoryId;
+}
+function canonicalSourceKey(kind, itemNumber) {
+	return kind === "issue" ? `github-issue:${itemNumber}` : `github-pr:${itemNumber}`;
+}
+function legacySourceKey(repositoryId, kind, itemNumber) {
+	return `github:${repositoryId}:${kind}:${itemNumber}`;
+}
+function provenanceTarget(repositoryId, pullRequestNumber) {
+	return `factory-pr-provenance:${repositoryId}:${pullRequestNumber}`;
+}
+function workItemSource(item) {
+	if (!item.externalSource) return "manual";
+	return item.externalSource.type === "pull-request" ? "github-pr" : "github-issue";
+}
+function workItemSourceKey(item) {
+	return item.externalSource?.externalId ?? null;
+}
+async function githubActor(github, input) {
+	let trusted = false;
+	try {
+		const permission = await github.getRepositoryCollaboratorPermission(input.installationId, input.repository, input.login);
+		trusted = permission !== void 0 && TRUSTED_PERMISSIONS.has(permission);
+	} catch {
+		trusted = false;
+	}
+	return {
+		type: "github",
+		login: input.login,
+		trusted,
+		factoryAuthored: input.factoryAuthored
+	};
+}
+function pullRequestProvenance(data) {
+	if (!data || data.kind !== "factory-pr-provenance" || typeof data.workItemId !== "string") return null;
+	return {
+		kind: "factory-pr-provenance",
+		workItemId: data.workItemId
+	};
+}
+var GithubRules = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	async ingest(parsed) {
+		const event = eventName(parsed);
+		const repository = object(parsed.payload.repository);
+		const installationId = number(object(parsed.payload.installation)?.id);
+		const repositoryId = number(repository?.id);
+		const repositoryName = string(repository?.full_name);
+		const login = string(object(parsed.payload.sender)?.login);
+		if (!event || !installationId || !repositoryId || !repositoryName || !login) return { status: "ignored" };
+		const projects = await this.options.sourceControl.projectRepositories.listByExternalRepository({
+			installationExternalId: String(installationId),
+			repositoryExternalId: String(repositoryId)
+		});
+		if (projects.length === 0) return { status: "ignored" };
+		const results = [];
+		for (const project of projects) results.push(await this.#ingestProject(parsed, event, installationId, repositoryId, repositoryName, login, project));
+		if (results.some((result) => result.status === "committed")) return { status: "committed" };
+		if (results.some((result) => result.status === "replayed")) return { status: "replayed" };
+		return results[0] ?? { status: "ignored" };
+	}
+	async #ingestProject(parsed, event, installationId, repositoryId, repositoryName, login, project) {
+		const factoryProject = await this.options.projects.get({
+			orgId: project.orgId,
+			id: project.factoryProjectId
+		});
+		if (!factoryProject) return { status: "missing" };
+		const issue = object(parsed.payload.issue);
+		const issueComment = object(parsed.payload.comment);
+		const changes = object(parsed.payload.changes);
+		const pullRequest = object(parsed.payload.pull_request);
+		const issueNumber = number(issue?.number);
+		const pullRequestNumber = number(pullRequest?.number);
+		const provenance = pullRequestNumber ? pullRequestProvenance((await this.options.integrationStorage.subscriptions.listByTarget(provenanceTarget(repositoryId, pullRequestNumber), { status: "active" })).find((subscription) => subscription.orgId === project.orgId)?.data) : null;
+		const reviewRequested = event === "pullRequestReviewRequested";
+		const requestedReviewer = string(object(parsed.payload.requested_reviewer)?.login);
+		const relatedItem = await this.#relatedItem(project.orgId, project.factoryProjectId, repositoryId, repositoryName, issueNumber, pullRequestNumber, string(object(pullRequest?.head)?.ref), reviewRequested ? null : provenance);
+		const actor = await githubActor(this.options.github, {
+			installationId,
+			repository: repositoryName,
+			login,
+			factoryAuthored: !reviewRequested && provenance !== null || login === `${this.options.github.slug}[bot]`
+		});
+		if (actor.type === "github" && actor.factoryAuthored && (event === "issueCommentCreated" || event === "issueCommentEdited") && string(issueComment?.body)?.includes(FACTORY_TRIAGE_COMMENT_MARKER)) return { status: "ignored" };
+		const context = {
+			tenant: {
+				orgId: project.orgId,
+				projectId: project.factoryProjectId
+			},
+			actor,
+			ingress: {
+				type: "github",
+				id: `${installationId}:${parsed.deliveryId}`
+			},
+			cause: `github.${event}`,
+			causalChain: [],
+			ruleSetVersion: this.options.rules.version,
+			...relatedItem ? {
+				item: {
+					id: relatedItem.id,
+					source: workItemSource(relatedItem),
+					sourceKey: workItemSourceKey(relatedItem),
+					parentWorkItemId: relatedItem.parentWorkItemId,
+					title: relatedItem.title,
+					url: relatedItem.externalSource?.url ?? null,
+					stages: relatedItem.stages
+				},
+				board: relatedItem.externalSource?.type === "pull-request" ? "review" : "work",
+				itemRevision: relatedItem.revision
+			} : {},
+			event,
+			deliveryId: parsed.deliveryId,
+			factory: { createdAt: factoryProject.createdAt.toISOString() },
+			repository: {
+				id: repositoryId,
+				fullName: repositoryName
+			},
+			...issueNumber && string(issue?.title) && string(issue?.html_url) ? { issue: {
+				number: issueNumber,
+				title: string(issue?.title),
+				url: string(issue?.html_url),
+				...string(issue?.created_at) ? { createdAt: string(issue?.created_at) } : {},
+				...string(issue?.updated_at) ? { updatedAt: string(issue?.updated_at) } : {},
+				assignees: actorLogins(issue?.assignees),
+				...string(issue?.state) === "closed" || string(issue?.state) === "open" ? { state: string(issue?.state) } : {},
+				...string(issue?.state_reason) ? { stateReason: string(issue?.state_reason) } : {}
+			} } : {},
+			...event === "issueEdited" ? { issueChange: {
+				title: Boolean(object(changes?.title)),
+				body: Boolean(object(changes?.body))
+			} } : {},
+			...number(issueComment?.id) ? { issueComment: {
+				id: number(issueComment?.id),
+				...string(issueComment?.body) ? { body: string(issueComment?.body) } : {},
+				...string(issueComment?.html_url) ? { url: string(issueComment?.html_url) } : {},
+				...string(object(issueComment?.user)?.login) ? { author: string(object(issueComment?.user)?.login) } : {},
+				...string(object(issueComment?.user)?.type) ? { authorType: string(object(issueComment?.user)?.type) } : {},
+				...string(issueComment?.created_at) ? { createdAt: string(issueComment?.created_at) } : {},
+				...string(issueComment?.updated_at) ? { updatedAt: string(issueComment?.updated_at) } : {}
+			} } : {},
+			...pullRequestNumber && string(pullRequest?.title) && string(pullRequest?.html_url) ? { pullRequest: {
+				number: pullRequestNumber,
+				title: string(pullRequest?.title),
+				url: string(pullRequest?.html_url),
+				...string(pullRequest?.created_at) ? { createdAt: string(pullRequest?.created_at) } : {},
+				state: string(pullRequest?.state) === "closed" ? "closed" : "open",
+				draft: boolean(pullRequest?.draft) ?? false,
+				merged: boolean(pullRequest?.merged) ?? false,
+				assignees: actorLogins(pullRequest?.assignees),
+				requestedReviewers: actorLogins(pullRequest?.requested_reviewers),
+				headBranch: string(object(pullRequest?.head)?.ref) ?? "",
+				baseBranch: string(object(pullRequest?.base)?.ref) ?? ""
+			} } : {},
+			...reviewRequested && requestedReviewer ? { reviewRequest: {
+				reviewer: requestedReviewer,
+				factoryReviewer: requestedReviewer === `${this.options.github.slug}[bot]`
+			} } : {},
+			...object(parsed.payload.review) ? { review: {
+				id: number(object(parsed.payload.review)?.id) ?? 0,
+				state: string(object(parsed.payload.review)?.state) ?? "unknown",
+				url: string(object(parsed.payload.review)?.html_url) ?? ""
+			} } : {}
+		};
+		const rule = resolveFactoryGithubRule(this.options.rules, event);
+		let decision;
+		let decisions = [];
+		let outcome = { status: "accepted" };
+		try {
+			decision = rule ? await withRuleTimeout(Promise.resolve(rule(Object.freeze(context)))) : void 0;
+			if (decision?.type === "reject") outcome = {
+				status: "rejected",
+				code: decision.code,
+				reason: decision.reason
+			};
+			else if (decision) decisions = validateFactoryRuleDecisions([decision]).map((entry) => ({ ...entry }));
+		} catch (error) {
+			const timedOut = error instanceof Error && error.message === "FACTORY_RULE_TIMEOUT";
+			outcome = {
+				status: "rejected",
+				code: timedOut ? "timeout" : "rule_error",
+				reason: timedOut ? "Factory rule evaluation timed out." : error instanceof Error ? error.message.slice(0, 2e3) : "Factory GitHub rule failed."
+			};
+		}
+		return { status: (await this.options.storage.commitRuleEvaluation({
+			orgId: project.orgId,
+			factoryProjectId: project.factoryProjectId,
+			workItemId: relatedItem?.id ?? null,
+			ingress: {
+				identity: `${installationId}:${parsed.deliveryId}`,
+				triggerType: `github.${event}`
+			},
+			ruleSetVersion: this.options.rules.version,
+			expectedRevision: relatedItem?.revision ?? null,
+			actor: { ...actor },
+			outcome,
+			decisions,
+			causalChain: [],
+			now: /* @__PURE__ */ new Date()
+		})).status };
+	}
+	async #relatedItem(orgId, projectId, repositoryId, repositoryFullName, issueNumber, pullRequestNumber, pullRequestHeadBranch, provenance) {
+		const items = await this.options.storage.list({
+			orgId,
+			factoryProjectId: projectId
+		});
+		if (provenance) return items.find((item) => item.id === provenance.workItemId);
+		if (issueNumber) return items.find((item) => item.externalSource?.externalId === canonicalSourceKey("issue", issueNumber) && cardBelongsToRepository(item, repositoryId, repositoryFullName)) ?? items.find((item) => item.externalSource?.externalId === legacySourceKey(repositoryId, "issue", issueNumber));
+		if (pullRequestNumber) return items.find((item) => item.externalSource?.externalId === canonicalSourceKey("pull-request", pullRequestNumber) && cardBelongsToRepository(item, repositoryId, repositoryFullName)) ?? items.find((item) => item.externalSource?.externalId === legacySourceKey(repositoryId, "pull-request", pullRequestNumber)) ?? (pullRequestHeadBranch ? items.find((item) => item.externalSource?.type !== "pull-request" && Object.values(item.sessions).some((session) => session.branch === pullRequestHeadBranch)) : void 0);
+	}
+};
+const RECONCILE_ERROR_SAMPLE_LIMIT = 5;
+function sameStrings(left, right) {
+	if (right === void 0) return true;
+	if (!Array.isArray(left)) return false;
+	const leftValues = new Set(left.flatMap((value) => typeof value === "string" ? [value] : []));
+	const rightValues = new Set(right);
+	return leftValues.size === rightValues.size && [...leftValues].every((value) => rightValues.has(value));
+}
+/**
+* Extracts the PR number a work item tracks, but only when the item belongs
+* to the given repository. Card URLs pin the repository unambiguously; the
+* legacy source key embeds the repository id. Canonical keys (`github-pr:N`)
+* carry no repository, so they are only trusted when the item has no URL —
+* a project mapped to multiple repositories must not reconcile one repo's
+* card against another repo's PR number.
+*/
+function reconcilablePullRequestNumber(item, repository) {
+	if (item.externalSource?.type !== "pull-request") return void 0;
+	const url = item.externalSource.url;
+	if (url) {
+		const match = /^https?:\/\/[^/]+\/(.+)\/pull\/(\d+)(?:[/?#]|$)/.exec(url);
+		if (!match) return void 0;
+		return match[1] === repository.fullName ? Number(match[2]) : void 0;
+	}
+	const externalId = item.externalSource.externalId;
+	const legacy = /^github:(\d+):pull-request:(\d+)$/.exec(externalId);
+	if (legacy) return Number(legacy[1]) === repository.id ? Number(legacy[2]) : void 0;
+	const canonical = /^github-pr:(\d+)$/.exec(externalId);
+	return canonical ? Number(canonical[1]) : void 0;
+}
+/**
+* Extracts the issue number a work item tracks, but only when the item
+* belongs to the given repository. Stricter than
+* {@link reconcilablePullRequestNumber}: a canonical key with no URL is only
+* trusted when the intake-stamped `githubRepositoryId` confirms the
+* repository, because the sweep initiates closes on its own.
+*/
+function reconcilableIssueNumber(item, repository) {
+	if (item.externalSource?.type !== "issue") return void 0;
+	const url = item.externalSource.url;
+	if (url) {
+		const match = /^https?:\/\/[^/]+\/(.+)\/issues\/(\d+)(?:[/?#]|$)/.exec(url);
+		if (!match) return void 0;
+		return match[1] === repository.fullName || item.metadata?.githubRepositoryId === repository.id ? Number(match[2]) : void 0;
+	}
+	const externalId = item.externalSource.externalId;
+	const legacy = /^github:(\d+):issue:(\d+)$/.exec(externalId);
+	if (legacy) return Number(legacy[1]) === repository.id ? Number(legacy[2]) : void 0;
+	const canonical = /^github-issue:(\d+)$/.exec(externalId);
+	if (!canonical) return void 0;
+	return item.metadata?.githubRepositoryId === repository.id ? Number(canonical[1]) : void 0;
+}
+function reconciledIssueClosedEvent(repository, issueNumber, state) {
+	return {
+		event: "issues",
+		deliveryId: `reconcile:${repository.id}:issue:${issueNumber}:closed`,
+		payload: {
+			action: "closed",
+			installation: { id: repository.installationId },
+			repository: {
+				id: repository.id,
+				full_name: repository.fullName
+			},
+			sender: { login: state.author ?? "github" },
+			issue: {
+				number: issueNumber,
+				title: state.title,
+				html_url: state.url,
+				state: "closed",
+				...state.stateReason ? { state_reason: state.stateReason } : {},
+				...state.createdAt ? { created_at: state.createdAt } : {},
+				...state.updatedAt ? { updated_at: state.updatedAt } : {},
+				assignees: (state.assignees ?? []).map((login) => ({ login }))
+			}
+		}
+	};
+}
+function reconciledClosedEvent(repository, pullRequestNumber, state) {
+	return {
+		event: "pull_request",
+		deliveryId: `reconcile:${repository.id}:pull-request:${pullRequestNumber}:${state.merged ? "merged" : "closed"}`,
+		payload: {
+			action: "closed",
+			installation: { id: repository.installationId },
+			repository: {
+				id: repository.id,
+				full_name: repository.fullName
+			},
+			sender: { login: state.mergedBy ?? "github" },
+			pull_request: {
+				number: pullRequestNumber,
+				title: state.title,
+				html_url: state.url,
+				...state.createdAt ? { created_at: state.createdAt } : {},
+				state: "closed",
+				draft: state.draft,
+				merged: state.merged,
+				assignees: (state.assignees ?? []).map((login) => ({ login })),
+				requested_reviewers: (state.requestedReviewers ?? []).map((login) => ({ login })),
+				head: { ref: state.headBranch },
+				base: { ref: state.baseBranch }
+			}
+		}
+	};
+}
+/**
+* The webhook handler retires subscriptions itself; the sweep replays only the
+* rules ingress, so without this the thread's PR chip and the workspace row
+* stay `open` forever on a deployment GitHub cannot reach.
+*/
+async function retireReconciledSubscriptions(storage, repository, pullRequestNumber, merged) {
+	const target = changeRequestTargetKey({
+		installationExternalId: String(repository.installationId),
+		repositoryExternalId: String(repository.id),
+		changeRequestId: String(pullRequestNumber)
+	});
+	const rows = await storage.subscriptions.listByTarget(target);
+	await Promise.all(rows.filter((row) => row.status === "open").map((row) => storage.subscriptions.updateStatus(row.id, merged ? "merged" : "closed")));
+}
+/**
+* State-based safety net for merge signals: webhooks and event-log tailing
+* can miss a merge (cursor gaps, downtime, terminally failed decisions), so
+* this sweep compares still-open PR cards against actual GitHub state and
+* replays the merge through the normal rules ingress when they disagree.
+*/
+function createGithubPullRequestReconciler(options, fetchPullRequest, fetchIssue) {
+	const rules = new GithubRules(options);
+	return async (repositories) => {
+		const summary = {
+			repositories: 0,
+			checked: 0,
+			merged: 0,
+			closed: 0,
+			issuesChecked: 0,
+			issuesClosed: 0,
+			failed: 0,
+			errors: []
+		};
+		const recordFailure = (repository, error, numbers) => {
+			summary.failed += 1;
+			if (summary.errors.length < RECONCILE_ERROR_SAMPLE_LIMIT) summary.errors.push({
+				repository: repository.fullName,
+				...numbers?.pullRequestNumber === void 0 ? {} : { pullRequestNumber: numbers.pullRequestNumber },
+				...numbers?.issueNumber === void 0 ? {} : { issueNumber: numbers.issueNumber },
+				error: error instanceof Error ? error.message : String(error)
+			});
+		};
+		const configured = new Set((await options.sourceControl.projectRepositories.listConfiguredExternalKeys()).map((key) => `${key.installationExternalId}\u0000${key.repositoryExternalId}`));
+		const scoped = repositories.filter((repository) => configured.has(`${repository.installationId}\u0000${repository.id}`));
+		summary.repositories = scoped.length;
+		for (const repository of scoped) {
+			let cardsByNumber;
+			const issueNumbers = /* @__PURE__ */ new Set();
+			try {
+				const projects = await options.sourceControl.projectRepositories.listByExternalRepository({
+					installationExternalId: String(repository.installationId),
+					repositoryExternalId: String(repository.id)
+				});
+				if (projects.length === 0) continue;
+				cardsByNumber = /* @__PURE__ */ new Map();
+				for (const project of projects) {
+					const items = await options.storage.list({
+						orgId: project.orgId,
+						factoryProjectId: project.factoryProjectId
+					});
+					for (const item of items) {
+						const stage = item.stages[0];
+						if (fetchIssue) {
+							const issueNumber = reconcilableIssueNumber(item, repository);
+							if (issueNumber && stage !== "done" && stage !== "canceled") issueNumbers.add(issueNumber);
+						}
+						const pullRequestNumber = reconcilablePullRequestNumber(item, repository);
+						if (!pullRequestNumber) continue;
+						const metadata = item.metadata ?? {};
+						const hasReconciledMetadata = (metadata.state === "open" || metadata.state === "closed") && typeof metadata.draft === "boolean" && typeof metadata.merged === "boolean" && typeof metadata.author === "string" && Array.isArray(metadata.assignees) && Array.isArray(metadata.requestedReviewers);
+						if ((stage === "done" || stage === "canceled") && hasReconciledMetadata) continue;
+						const cards = cardsByNumber.get(pullRequestNumber) ?? [];
+						cards.push(item);
+						cardsByNumber.set(pullRequestNumber, cards);
+					}
+				}
+			} catch (error) {
+				recordFailure(repository, error);
+				continue;
+			}
+			for (const [pullRequestNumber, cards] of cardsByNumber) try {
+				const state = await fetchPullRequest({
+					installationId: repository.installationId,
+					repository: repository.fullName,
+					number: pullRequestNumber
+				});
+				summary.checked += 1;
+				if (!state) continue;
+				for (const card of cards) {
+					const metadata = card.metadata ?? {};
+					const statusChanged = metadata.state !== state.state || metadata.draft !== state.draft || metadata.merged !== state.merged;
+					const authorChanged = state.author !== void 0 && metadata.author !== state.author;
+					const assigneesChanged = !sameStrings(metadata.assignees, state.assignees);
+					const reviewersChanged = !sameStrings(metadata.requestedReviewers, state.requestedReviewers);
+					if (!statusChanged && !authorChanged && !assigneesChanged && !reviewersChanged) continue;
+					try {
+						await options.storage.update({
+							orgId: card.orgId,
+							id: card.id,
+							userId: "factory-rule-dispatcher",
+							patch: { metadata: {
+								state: state.state,
+								draft: state.draft,
+								merged: state.merged,
+								...state.author ? { author: state.author } : {},
+								...state.assignees ? { assignees: state.assignees } : {},
+								...state.requestedReviewers ? { requestedReviewers: state.requestedReviewers } : {}
+							} }
+						});
+					} catch (error) {
+						recordFailure(repository, error, { pullRequestNumber });
+					}
+				}
+				if (state.state !== "closed") continue;
+				await rules.ingest(reconciledClosedEvent(repository, pullRequestNumber, state));
+				await retireReconciledSubscriptions(options.integrationStorage, repository, pullRequestNumber, state.merged);
+				if (state.merged) summary.merged += 1;
+				else summary.closed += 1;
+			} catch (error) {
+				recordFailure(repository, error, { pullRequestNumber });
+			}
+			if (!fetchIssue) continue;
+			for (const issueNumber of issueNumbers) try {
+				const state = await fetchIssue({
+					installationId: repository.installationId,
+					repository: repository.fullName,
+					number: issueNumber
+				});
+				summary.issuesChecked += 1;
+				if (!state || state.state !== "closed") continue;
+				await rules.ingest(reconciledIssueClosedEvent(repository, issueNumber, state));
+				summary.issuesClosed += 1;
+			} catch (error) {
+				recordFailure(repository, error, { issueNumber });
+			}
+		}
+		return summary;
+	};
+}
+function githubRulesOptions(github, context) {
+	if (!context.rules) return void 0;
+	return {
+		github,
+		sourceControl: context.storage.sourceControl,
+		integrationStorage: context.storage.generic,
+		projects: context.storage.projects,
+		storage: context.rules.workItems,
+		rules: context.rules.config
+	};
+}
+function attachGithubRules(github, context) {
+	const options = githubRulesOptions(github, context);
+	if (!options) return void 0;
+	const rules = new GithubRules(options);
+	return (event) => rules.ingest(event);
+}
+function attachGithubReconciler(github, context, fetchPullRequest, fetchIssue) {
+	const options = githubRulesOptions(github, context);
+	if (!options) return void 0;
+	return createGithubPullRequestReconciler(options, fetchPullRequest, fetchIssue);
+}
+//#endregion
+export { GithubRules, attachGithubReconciler, attachGithubRules, createGithubPullRequestReconciler, reconciledClosedEvent, reconciledIssueClosedEvent };
+
+//# sourceMappingURL=rules.js.map