@kici-dev/engine 0.0.0 → 0.1.0

package/dist/trigger/matcher.js

@@ -0,0 +1,704 @@
+import "../chunk-gOLHoazu.js";
+import { createTraceEntry, createWorkflowDecision } from "./decision-trace.js";
+import { matchJsonPath, matchJsonPathNot } from "./jsonpath-matcher.js";
+import picomatch from "picomatch";
+//#region src/trigger/matcher.ts
+/**
+* Trigger matching engine for evaluating workflow triggers against webhook events.
+* Single source of truth -- replaces duplicate logic in compiler and orchestrator.
+*/
+function splitStringPatterns(patterns) {
+	const include = [];
+	const exclude = [];
+	for (const p of patterns) if (p.startsWith("!")) exclude.push(p.slice(1));
+	else include.push(p);
+	return {
+		include,
+		exclude
+	};
+}
+function splitBranchPatterns(patterns) {
+	const include = [];
+	const exclude = [];
+	for (const p of patterns) if (p.pattern.startsWith("!")) exclude.push({
+		...p,
+		pattern: p.pattern.slice(1)
+	});
+	else include.push(p);
+	return {
+		include,
+		exclude
+	};
+}
+/**
+* Match a branch pattern against a branch name.
+*/
+function matchBranchPattern(pattern, branch) {
+	if (pattern.type === "glob") return picomatch.isMatch(branch, pattern.pattern);
+	else return new RegExp(pattern.pattern, pattern.flags).test(branch);
+}
+/**
+* Match any of the branch patterns.
+* Returns true if patterns array is empty (no filter = match all).
+*/
+function matchAnyBranch(patterns, branch) {
+	if (patterns.length === 0) return true;
+	return patterns.some((p) => matchBranchPattern(p, branch));
+}
+/**
+* Match path patterns against changed files.
+* Patterns prefixed with ! are exclusions. Remaining patterns are inclusions.
+* An all-negation array has implicit match-all semantics for non-excluded files.
+*/
+function matchPathPatterns(paths, changedFiles) {
+	if (paths.length === 0) return true;
+	if (changedFiles.length === 0) return false;
+	const { include, exclude } = splitStringPatterns(paths);
+	let relevantFiles = changedFiles;
+	if (exclude.length > 0) {
+		relevantFiles = changedFiles.filter((file) => !exclude.some((pattern) => picomatch.isMatch(file, pattern)));
+		if (relevantFiles.length === 0) return false;
+	}
+	if (include.length === 0) return true;
+	return relevantFiles.some((file) => include.some((pattern) => picomatch.isMatch(file, pattern)));
+}
+/**
+* Match repo patterns against a source repository identifier.
+* Patterns with ! prefix in the pattern string are exclusions.
+* An all-negation array has implicit match-all semantics for non-excluded repos.
+* Empty array = no filtering (matches all repos).
+*/
+function matchRepoPatterns(repos, sourceRepo) {
+	if (repos.length === 0) return true;
+	const { include, exclude } = splitBranchPatterns(repos);
+	if (exclude.length > 0) {
+		if (exclude.some((p) => matchBranchPattern(p, sourceRepo))) return false;
+	}
+	if (include.length === 0) return true;
+	return include.some((p) => matchBranchPattern(p, sourceRepo));
+}
+/**
+* Evaluate repo pattern filter for a trigger against an event.
+* Returns true if matched (or no filter), false if filtered out.
+* Adds trace entries for debugging.
+*/
+function evaluateRepoFilter(trigger, event, traces) {
+	if (trigger.repos?.length) {
+		if (!event.sourceRepo) {
+			traces.push(createTraceEntry("repo", "required", "(missing)", false));
+			return false;
+		}
+		const { include, exclude } = splitBranchPatterns(trigger.repos);
+		const repoMatch = matchRepoPatterns(trigger.repos, event.sourceRepo);
+		traces.push(createTraceEntry("repo", `include:[${include.map((p) => p.pattern).join(",")}] exclude:[${exclude.map((p) => p.pattern).join(",")}]`, event.sourceRepo, repoMatch));
+		if (!repoMatch) return false;
+	}
+	return true;
+}
+/**
+* Match a PR trigger against a simulated event.
+*/
+function matchPrTrigger(trigger, event, traces) {
+	if (event.type !== "pull_request") {
+		traces.push(createTraceEntry("event type", "pull_request", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "pull_request", event.type, true));
+	if (trigger.events.length > 0) {
+		const action = event.action ?? "";
+		const actionMatches = trigger.events.includes(action);
+		traces.push(createTraceEntry("action", trigger.events.join("|"), action, actionMatches));
+		if (!actionMatches) return false;
+	}
+	if (trigger.targetBranches.length > 0) {
+		const matches = matchAnyBranch(trigger.targetBranches, event.targetBranch);
+		traces.push(createTraceEntry("target branch", trigger.targetBranches.map((p) => p.pattern).join("|"), event.targetBranch, matches));
+		if (!matches) return false;
+	}
+	if (trigger.sourceBranches.length > 0) {
+		if (!event.sourceBranch) {
+			traces.push(createTraceEntry("source branch", trigger.sourceBranches.map((p) => p.pattern).join("|"), "(missing)", false, "Event has no sourceBranch but trigger requires source branch filtering"));
+			return false;
+		}
+		const matches = matchAnyBranch(trigger.sourceBranches, event.sourceBranch);
+		traces.push(createTraceEntry("source branch", trigger.sourceBranches.map((p) => p.pattern).join("|"), event.sourceBranch, matches));
+		if (!matches) return false;
+	}
+	if (trigger.paths.length > 0) {
+		const changedFiles = event.changedFiles ?? [];
+		const { include, exclude } = splitStringPatterns(trigger.paths);
+		const matches = matchPathPatterns(trigger.paths, changedFiles);
+		traces.push(createTraceEntry("paths", `include: [${include.join(", ")}] exclude: [${exclude.join(", ")}]`, `[${changedFiles.join(", ")}]`, matches));
+		if (!matches) return false;
+	}
+	if (!evaluateRepoFilter(trigger, event, traces)) return false;
+	return true;
+}
+/**
+* Match a push trigger against a simulated event.
+*/
+function matchPushTrigger(trigger, event, traces) {
+	if (event.type !== "push") {
+		traces.push(createTraceEntry("event type", "push", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "push", event.type, true));
+	if (trigger.branches.length > 0) {
+		const matches = matchAnyBranch(trigger.branches, event.targetBranch);
+		traces.push(createTraceEntry("branch", trigger.branches.map((p) => p.pattern).join("|"), event.targetBranch, matches));
+		if (!matches) return false;
+	}
+	if (trigger.paths.length > 0) {
+		const changedFiles = event.changedFiles ?? [];
+		const { include, exclude } = splitStringPatterns(trigger.paths);
+		const matches = matchPathPatterns(trigger.paths, changedFiles);
+		traces.push(createTraceEntry("paths", `include: [${include.join(", ")}] exclude: [${exclude.join(", ")}]`, `[${changedFiles.join(", ")}]`, matches));
+		if (!matches) return false;
+	}
+	if (!evaluateRepoFilter(trigger, event, traces)) return false;
+	return true;
+}
+/**
+* Match a tag trigger against a simulated event.
+* Tag name is expected in event.targetBranch (normalizer sets it there).
+*/
+function matchTagTrigger(trigger, event, traces) {
+	if (event.type !== "tag") {
+		traces.push(createTraceEntry("event type", "tag", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "tag", event.type, true));
+	if (trigger.patterns.length > 0) {
+		const matches = matchAnyBranch(trigger.patterns, event.targetBranch);
+		traces.push(createTraceEntry("tag pattern", trigger.patterns.map((p) => p.pattern).join("|"), event.targetBranch, matches));
+		if (!matches) return false;
+	}
+	if (!evaluateRepoFilter(trigger, event, traces)) return false;
+	return true;
+}
+/**
+* Match a comment trigger against a simulated event.
+* Supports action filter, source filter (issue vs PR), and bodyMatch (glob/regex).
+*/
+function matchCommentTrigger(trigger, event, traces) {
+	if (event.type !== "comment") {
+		traces.push(createTraceEntry("event type", "comment", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "comment", event.type, true));
+	if (trigger.actions.length > 0) {
+		const action = event.action ?? "";
+		const matches = trigger.actions.includes(action);
+		traces.push(createTraceEntry("action", trigger.actions.join("|"), action, matches));
+		if (!matches) return false;
+	}
+	if (trigger.source) {
+		const issue = event.payload.issue;
+		const isFromPr = !!(issue && "pull_request" in issue);
+		if (trigger.source === "issue") {
+			const matches = !isFromPr;
+			traces.push(createTraceEntry("source", "issue", isFromPr ? "pr" : "issue", matches));
+			if (!matches) return false;
+		} else {
+			const matches = isFromPr;
+			traces.push(createTraceEntry("source", "pr", isFromPr ? "pr" : "issue", matches));
+			if (!matches) return false;
+		}
+	}
+	if (trigger.bodyMatch) {
+		const body = event.payload.comment?.body ?? "";
+		if (trigger.bodyMatch.type === "glob") {
+			const matches = picomatch.isMatch(body, trigger.bodyMatch.pattern);
+			traces.push(createTraceEntry("bodyMatch (glob)", trigger.bodyMatch.pattern, body, matches));
+			if (!matches) return false;
+		} else {
+			const matches = new RegExp(trigger.bodyMatch.pattern, trigger.bodyMatch.flags).test(body);
+			traces.push(createTraceEntry("bodyMatch (regex)", trigger.bodyMatch.pattern, body, matches));
+			if (!matches) return false;
+		}
+	}
+	if (!evaluateRepoFilter(trigger, event, traces)) return false;
+	return true;
+}
+/**
+* Match a review trigger against a simulated event.
+* Supports action and review state filters.
+*/
+function matchReviewTrigger(trigger, event, traces) {
+	if (event.type !== "review") {
+		traces.push(createTraceEntry("event type", "review", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "review", event.type, true));
+	if (trigger.actions.length > 0) {
+		const action = event.action ?? "";
+		const matches = trigger.actions.includes(action);
+		traces.push(createTraceEntry("action", trigger.actions.join("|"), action, matches));
+		if (!matches) return false;
+	}
+	if (trigger.states.length > 0) {
+		const state = event.payload.review?.state ?? "";
+		const matches = trigger.states.includes(state);
+		traces.push(createTraceEntry("state", trigger.states.join("|"), state, matches));
+		if (!matches) return false;
+	}
+	if (!evaluateRepoFilter(trigger, event, traces)) return false;
+	return true;
+}
+/**
+* Match a review comment trigger against a simulated event.
+* Supports action filter.
+*/
+function matchReviewCommentTrigger(trigger, event, traces) {
+	if (event.type !== "review_comment") {
+		traces.push(createTraceEntry("event type", "review_comment", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "review_comment", event.type, true));
+	if (trigger.actions.length > 0) {
+		const action = event.action ?? "";
+		const matches = trigger.actions.includes(action);
+		traces.push(createTraceEntry("action", trigger.actions.join("|"), action, matches));
+		if (!matches) return false;
+	}
+	if (!evaluateRepoFilter(trigger, event, traces)) return false;
+	return true;
+}
+/**
+* Match a release trigger against a simulated event.
+* Supports action filter (published, created, etc.).
+*/
+function matchReleaseTrigger(trigger, event, traces) {
+	if (event.type !== "release") {
+		traces.push(createTraceEntry("event type", "release", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "release", event.type, true));
+	if (trigger.actions.length > 0) {
+		const action = event.action ?? "";
+		const matches = trigger.actions.includes(action);
+		traces.push(createTraceEntry("action", trigger.actions.join("|"), action, matches));
+		if (!matches) return false;
+	}
+	if (!evaluateRepoFilter(trigger, event, traces)) return false;
+	return true;
+}
+/**
+* Match a dispatch trigger against a simulated event.
+* GitHub sends event_type as action for repository_dispatch.
+*/
+function matchDispatchTrigger(trigger, event, traces) {
+	if (event.type !== "dispatch") {
+		traces.push(createTraceEntry("event type", "dispatch", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "dispatch", event.type, true));
+	if (trigger.types.length > 0) {
+		const action = event.action ?? "";
+		const matches = trigger.types.includes(action);
+		traces.push(createTraceEntry("dispatch type", trigger.types.join("|"), action, matches));
+		if (!matches) return false;
+	}
+	if (!evaluateRepoFilter(trigger, event, traces)) return false;
+	return true;
+}
+/**
+* Match a create trigger against a simulated event.
+* Checks refType and ref pattern against payload fields.
+*/
+function matchCreateTrigger(trigger, event, traces) {
+	if (event.type !== "create") {
+		traces.push(createTraceEntry("event type", "create", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "create", event.type, true));
+	if (trigger.refTypes.length > 0) {
+		const refType = event.payload.ref_type;
+		const matches = trigger.refTypes.includes(refType);
+		traces.push(createTraceEntry("ref type", trigger.refTypes.join("|"), refType, matches));
+		if (!matches) return false;
+	}
+	if (trigger.patterns.length > 0) {
+		const ref = event.payload.ref;
+		const matches = matchAnyBranch(trigger.patterns, ref);
+		traces.push(createTraceEntry("ref pattern", trigger.patterns.map((p) => p.pattern).join("|"), ref, matches));
+		if (!matches) return false;
+	}
+	if (!evaluateRepoFilter(trigger, event, traces)) return false;
+	return true;
+}
+/**
+* Match a delete trigger against a simulated event.
+* Same structure as create trigger.
+*/
+function matchDeleteTrigger(trigger, event, traces) {
+	if (event.type !== "delete") {
+		traces.push(createTraceEntry("event type", "delete", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "delete", event.type, true));
+	if (trigger.refTypes.length > 0) {
+		const refType = event.payload.ref_type;
+		const matches = trigger.refTypes.includes(refType);
+		traces.push(createTraceEntry("ref type", trigger.refTypes.join("|"), refType, matches));
+		if (!matches) return false;
+	}
+	if (trigger.patterns.length > 0) {
+		const ref = event.payload.ref;
+		const matches = matchAnyBranch(trigger.patterns, ref);
+		traces.push(createTraceEntry("ref pattern", trigger.patterns.map((p) => p.pattern).join("|"), ref, matches));
+		if (!matches) return false;
+	}
+	if (!evaluateRepoFilter(trigger, event, traces)) return false;
+	return true;
+}
+/**
+* Match a status trigger against a simulated event.
+* Checks context via picomatch and state filter.
+*/
+function matchStatusTrigger(trigger, event, traces) {
+	if (event.type !== "status") {
+		traces.push(createTraceEntry("event type", "status", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "status", event.type, true));
+	if (trigger.contexts.length > 0) {
+		const context = event.payload.context ?? "";
+		const matches = trigger.contexts.some((pattern) => picomatch.isMatch(context, pattern));
+		traces.push(createTraceEntry("context", trigger.contexts.join("|"), context, matches));
+		if (!matches) return false;
+	}
+	if (trigger.states.length > 0) {
+		const state = event.payload.state ?? "";
+		const matches = trigger.states.includes(state);
+		traces.push(createTraceEntry("state", trigger.states.join("|"), state, matches));
+		if (!matches) return false;
+	}
+	if (!evaluateRepoFilter(trigger, event, traces)) return false;
+	return true;
+}
+/**
+* Match a workflow_run trigger against a simulated event.
+* Checks action, workflow name, and conclusion filters.
+*/
+function matchWorkflowRunTrigger(trigger, event, traces) {
+	if (event.type !== "workflow_run") {
+		traces.push(createTraceEntry("event type", "workflow_run", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "workflow_run", event.type, true));
+	if (trigger.actions.length > 0) {
+		const action = event.action ?? "";
+		const matches = trigger.actions.includes(action);
+		traces.push(createTraceEntry("action", trigger.actions.join("|"), action, matches));
+		if (!matches) return false;
+	}
+	const workflowRun = event.payload.workflow_run;
+	if (trigger.workflows.length > 0) {
+		const name = workflowRun?.name ?? "";
+		const matches = trigger.workflows.includes(name);
+		traces.push(createTraceEntry("workflow name", trigger.workflows.join("|"), name, matches));
+		if (!matches) return false;
+	}
+	if (trigger.conclusions.length > 0) {
+		const conclusion = workflowRun?.conclusion ?? "";
+		const matches = trigger.conclusions.includes(conclusion);
+		traces.push(createTraceEntry("conclusion", trigger.conclusions.join("|"), conclusion, matches));
+		if (!matches) return false;
+	}
+	if (!evaluateRepoFilter(trigger, event, traces)) return false;
+	return true;
+}
+/**
+* Match a fork trigger against a simulated event.
+* Fork triggers match unconditionally (no filter fields).
+*/
+function matchForkTrigger(trigger, event, traces) {
+	if (event.type !== "fork") {
+		traces.push(createTraceEntry("event type", "fork", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "fork", event.type, true));
+	if (!evaluateRepoFilter(trigger, event, traces)) return false;
+	return true;
+}
+/**
+* Match a star trigger against a simulated event.
+* Supports action filter (created, deleted).
+*/
+function matchStarTrigger(trigger, event, traces) {
+	if (event.type !== "star") {
+		traces.push(createTraceEntry("event type", "star", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "star", event.type, true));
+	if (trigger.actions.length > 0) {
+		const action = event.action ?? "";
+		const matches = trigger.actions.includes(action);
+		traces.push(createTraceEntry("action", trigger.actions.join("|"), action, matches));
+		if (!matches) return false;
+	}
+	if (!evaluateRepoFilter(trigger, event, traces)) return false;
+	return true;
+}
+/**
+* Match a watch trigger against a simulated event.
+* Supports action filter (started).
+*/
+function matchWatchTrigger(trigger, event, traces) {
+	if (event.type !== "watch") {
+		traces.push(createTraceEntry("event type", "watch", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "watch", event.type, true));
+	if (trigger.actions.length > 0) {
+		const action = event.action ?? "";
+		const matches = trigger.actions.includes(action);
+		traces.push(createTraceEntry("action", trigger.actions.join("|"), action, matches));
+		if (!matches) return false;
+	}
+	if (!evaluateRepoFilter(trigger, event, traces)) return false;
+	return true;
+}
+/**
+* Match a generic webhook trigger against a simulated event.
+* Matches event type against the events array, then optionally filters by action.
+*/
+function matchWebhookTrigger(trigger, event, traces) {
+	const eventMatches = trigger.events.includes(event.type);
+	traces.push(createTraceEntry("event type", trigger.events.join("|"), event.type, eventMatches));
+	if (!eventMatches) return false;
+	if (trigger.actions.length > 0) {
+		const action = event.action ?? "";
+		const matches = trigger.actions.includes(action);
+		traces.push(createTraceEntry("action", trigger.actions.join("|"), action, matches));
+		if (!matches) return false;
+	}
+	if (!evaluateRepoFilter(trigger, event, traces)) return false;
+	return true;
+}
+/**
+* Match a kici_event trigger against a simulated event.
+* Checks event name, optional JSONPath match/not, and source filter.
+*/
+function matchKiciEventTrigger(trigger, event, traces) {
+	if (event.type !== "kici_event") {
+		traces.push(createTraceEntry("event type", "kici_event", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "kici_event", event.type, true));
+	const eventName = event.payload.eventName ?? "";
+	const nameMatches = eventName === trigger.eventName;
+	traces.push(createTraceEntry("event name", trigger.eventName, eventName, nameMatches));
+	if (!nameMatches) return false;
+	if (trigger.match && Object.keys(trigger.match).length > 0) {
+		const matches = matchJsonPath(event.payload.payload ?? {}, trigger.match);
+		traces.push(createTraceEntry("jsonpath match", JSON.stringify(trigger.match), "(payload)", matches));
+		if (!matches) return false;
+	}
+	if (trigger.not && Object.keys(trigger.not).length > 0) {
+		const passes = matchJsonPathNot(event.payload.payload ?? {}, trigger.not);
+		traces.push(createTraceEntry("jsonpath not", JSON.stringify(trigger.not), "(payload)", passes));
+		if (!passes) return false;
+	}
+	if (trigger.source) {
+		const sourceRepo = event.payload.sourceRepo ?? "";
+		const matches = sourceRepo === trigger.source;
+		traces.push(createTraceEntry("source", trigger.source, sourceRepo, matches));
+		if (!matches) return false;
+	}
+	return true;
+}
+/**
+* Match a workflow_complete trigger against a simulated event.
+* Checks workflow name, status array, and source filter.
+*/
+function matchWorkflowCompleteTrigger(trigger, event, traces) {
+	if (event.type !== "workflow_complete") {
+		traces.push(createTraceEntry("event type", "workflow_complete", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "workflow_complete", event.type, true));
+	if (trigger.name) {
+		const workflowName = event.payload.workflowName ?? "";
+		const matches = workflowName === trigger.name;
+		traces.push(createTraceEntry("workflow name", trigger.name, workflowName, matches));
+		if (!matches) return false;
+	}
+	if (trigger.status && trigger.status.length > 0) {
+		const status = event.payload.status ?? "";
+		const matches = trigger.status.includes(status);
+		traces.push(createTraceEntry("status", trigger.status.join("|"), status, matches));
+		if (!matches) return false;
+	}
+	if (trigger.source) {
+		const sourceRepo = event.payload.sourceRepo ?? "";
+		const matches = sourceRepo === trigger.source;
+		traces.push(createTraceEntry("source", trigger.source, sourceRepo, matches));
+		if (!matches) return false;
+	}
+	return true;
+}
+/**
+* Match a job_complete trigger against a simulated event.
+* Checks workflow name, job name, status array, and source filter.
+*/
+function matchJobCompleteTrigger(trigger, event, traces) {
+	if (event.type !== "job_complete") {
+		traces.push(createTraceEntry("event type", "job_complete", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "job_complete", event.type, true));
+	if (trigger.workflow) {
+		const workflowName = event.payload.workflowName ?? "";
+		const matches = workflowName === trigger.workflow;
+		traces.push(createTraceEntry("workflow name", trigger.workflow, workflowName, matches));
+		if (!matches) return false;
+	}
+	if (trigger.job) {
+		const jobName = event.payload.jobName ?? "";
+		const matches = jobName === trigger.job;
+		traces.push(createTraceEntry("job name", trigger.job, jobName, matches));
+		if (!matches) return false;
+	}
+	if (trigger.status && trigger.status.length > 0) {
+		const status = event.payload.status ?? "";
+		const matches = trigger.status.includes(status);
+		traces.push(createTraceEntry("status", trigger.status.join("|"), status, matches));
+		if (!matches) return false;
+	}
+	if (trigger.source) {
+		const sourceRepo = event.payload.sourceRepo ?? "";
+		const matches = sourceRepo === trigger.source;
+		traces.push(createTraceEntry("source", trigger.source, sourceRepo, matches));
+		if (!matches) return false;
+	}
+	return true;
+}
+/**
+* Match a generic_webhook trigger against a simulated event.
+* Checks source ID, optional events array, and JSONPath match/not.
+*/
+function matchGenericWebhookTrigger(trigger, event, traces) {
+	if (event.type !== "generic_webhook") {
+		traces.push(createTraceEntry("event type", "generic_webhook", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "generic_webhook", event.type, true));
+	const eventSource = event.payload.source ?? "";
+	const sourceMatches = eventSource === trigger.source;
+	traces.push(createTraceEntry("source", trigger.source, eventSource, sourceMatches));
+	if (!sourceMatches) return false;
+	if (trigger.events && trigger.events.length > 0) {
+		const eventType = event.payload.eventType ?? event.action ?? "";
+		const matches = trigger.events.includes(eventType);
+		traces.push(createTraceEntry("event type filter", trigger.events.join("|"), eventType, matches));
+		if (!matches) return false;
+	}
+	if (trigger.match && Object.keys(trigger.match).length > 0) {
+		const matches = matchJsonPath(event.payload, trigger.match);
+		traces.push(createTraceEntry("jsonpath match", JSON.stringify(trigger.match), "(payload)", matches));
+		if (!matches) return false;
+	}
+	if (trigger.not && Object.keys(trigger.not).length > 0) {
+		const passes = matchJsonPathNot(event.payload, trigger.not);
+		traces.push(createTraceEntry("jsonpath not", JSON.stringify(trigger.not), "(payload)", passes));
+		if (!passes) return false;
+	}
+	return true;
+}
+/**
+* Match a schedule trigger against a simulated event.
+* Schedule triggers match when the event type is 'schedule' and the cron expression matches.
+*/
+function matchScheduleTrigger(trigger, event, traces) {
+	if (event.type !== "schedule") {
+		traces.push(createTraceEntry("event type", "schedule", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "schedule", event.type, true));
+	const cronExpression = event.payload.cronExpression ?? "";
+	const matches = cronExpression === trigger.cronExpression;
+	traces.push(createTraceEntry("cron expression", trigger.cronExpression, cronExpression, matches));
+	if (!matches) return false;
+	return true;
+}
+/**
+* Match a lifecycle trigger against a simulated event.
+* Lifecycle triggers match when event type is 'lifecycle', the lifecycle event is in the trigger's
+* events array, and optionally the source repo matches.
+*/
+function matchLifecycleTrigger(trigger, event, traces) {
+	if (event.type !== "lifecycle") {
+		traces.push(createTraceEntry("event type", "lifecycle", event.type, false));
+		return false;
+	}
+	traces.push(createTraceEntry("event type", "lifecycle", event.type, true));
+	const lifecycleEvent = event.payload.lifecycleEvent ?? "";
+	const eventMatches = trigger.events.includes(lifecycleEvent);
+	traces.push(createTraceEntry("lifecycle event", trigger.events.join("|"), lifecycleEvent, eventMatches));
+	if (!eventMatches) return false;
+	if (trigger.sources && trigger.sources.length > 0) {
+		const sourceRepo = event.payload.sourceRepo ?? "";
+		const sourceMatches = trigger.sources.includes(sourceRepo);
+		traces.push(createTraceEntry("source", trigger.sources.join("|"), sourceRepo, sourceMatches));
+		if (!sourceMatches) return false;
+	}
+	return true;
+}
+/**
+* Match a trigger against a simulated event.
+*/
+function matchTrigger(trigger, event, traces) {
+	switch (trigger._type) {
+		case "pr": return matchPrTrigger(trigger, event, traces);
+		case "push": return matchPushTrigger(trigger, event, traces);
+		case "tag": return matchTagTrigger(trigger, event, traces);
+		case "comment": return matchCommentTrigger(trigger, event, traces);
+		case "review": return matchReviewTrigger(trigger, event, traces);
+		case "review_comment": return matchReviewCommentTrigger(trigger, event, traces);
+		case "release": return matchReleaseTrigger(trigger, event, traces);
+		case "dispatch": return matchDispatchTrigger(trigger, event, traces);
+		case "create": return matchCreateTrigger(trigger, event, traces);
+		case "delete": return matchDeleteTrigger(trigger, event, traces);
+		case "status": return matchStatusTrigger(trigger, event, traces);
+		case "workflow_run": return matchWorkflowRunTrigger(trigger, event, traces);
+		case "fork": return matchForkTrigger(trigger, event, traces);
+		case "star": return matchStarTrigger(trigger, event, traces);
+		case "watch": return matchWatchTrigger(trigger, event, traces);
+		case "webhook": return matchWebhookTrigger(trigger, event, traces);
+		case "kici_event": return matchKiciEventTrigger(trigger, event, traces);
+		case "workflow_complete": return matchWorkflowCompleteTrigger(trigger, event, traces);
+		case "job_complete": return matchJobCompleteTrigger(trigger, event, traces);
+		case "generic_webhook": return matchGenericWebhookTrigger(trigger, event, traces);
+		case "schedule": return matchScheduleTrigger(trigger, event, traces);
+		case "lifecycle": return matchLifecycleTrigger(trigger, event, traces);
+		default: return false;
+	}
+}
+/**
+* Match all triggers for a workflow against an event.
+* Returns WorkflowDecision with full trace.
+*/
+function matchWorkflowTriggers(workflow, event) {
+	const allTraces = [];
+	if (workflow.triggers.length === 0) return createWorkflowDecision(workflow.name, false, [], void 0, "No triggers defined");
+	for (let i = 0; i < workflow.triggers.length; i++) {
+		const trigger = workflow.triggers[i];
+		if (trigger == null) continue;
+		const triggerTraces = [];
+		if (matchTrigger(trigger, event, triggerTraces)) return createWorkflowDecision(workflow.name, true, triggerTraces, i, `Matched trigger ${i + 1} (${trigger._type})`);
+		allTraces.push(...triggerTraces);
+	}
+	return createWorkflowDecision(workflow.name, false, allTraces, void 0, "No triggers matched");
+}
+/**
+* Match all workflows against an event.
+*/
+function matchAllWorkflows(workflows, event) {
+	return workflows.map((w) => matchWorkflowTriggers(w, event));
+}
+//#endregion
+export { matchAllWorkflows, matchBranchPattern, matchPathPatterns, matchRepoPatterns, matchWorkflowTriggers };
+
+//# sourceMappingURL=matcher.js.map