@mastra/factory 0.15.1-alpha.0 → 0.16.0-alpha.11

package/dist/integrations/platform/jira/integration.d.ts

@@ -0,0 +1,65 @@
+import type { RequestContext } from '@mastra/core/request-context';
+import type { ApiRoute } from '@mastra/core/server';
+import type { MastraWorker } from '@mastra/core/worker';
+import type { Intake, IntakeIssue } from '../../../capabilities/intake.js';
+import type { RouteAuth } from '../../../routes/route.js';
+import type { FactoryProjectsStorage } from '../../../storage/domains/projects/base.js';
+import type { FactoryIntegration, IntegrationContext, IntegrationTools } from '../../base.js';
+import type { JiraEventRules, JiraRuleOverrides } from '../../jira/default-rules.js';
+import { type PlatformApiClientConfig } from '../api-client.js';
+interface PlatformIntegrationConnection {
+    id: string;
+    integrationId: string;
+    status: 'active' | 'needs_reauth';
+    accountLabel: string | null;
+}
+interface JiraIssueReference {
+    connectionId: string;
+    issueId: string;
+    projectId?: string;
+}
+export interface PlatformJiraIntegrationConfig {
+    clientConfig?: PlatformApiClientConfig;
+    /** Per-event replacements; omitted events retain defaults, null disables. */
+    rules?: JiraRuleOverrides;
+}
+export declare class PlatformJiraIntegration implements FactoryIntegration {
+    #private;
+    readonly id = "jira";
+    get rules(): JiraEventRules;
+    constructor(config?: PlatformJiraIntegrationConfig);
+    initialize({ projects, auth }: {
+        projects: FactoryProjectsStorage;
+        auth: RouteAuth;
+    }): void;
+    get projects(): FactoryProjectsStorage;
+    get authEnabled(): boolean;
+    resolveOrgId(resourceId: string): Promise<string | null>;
+    clearCaches(): void;
+    listConnections(): Promise<PlatformIntegrationConnection[]>;
+    hasActiveConnections(): Promise<boolean>;
+    readonly intake: Intake;
+    listActiveIssues(cursor?: string, sourceIds?: string[], labels?: string[]): Promise<{
+        issues: Array<IntakeIssue & {
+            sourceId: string;
+            externalId: string;
+            site: string;
+        }>;
+        nextCursor: string | null;
+    }>;
+    workers(ctx: IntegrationContext): MastraWorker[];
+    routes(ctx: IntegrationContext): ApiRoute[];
+    agentTools(args: {
+        requestContext: RequestContext;
+    }): Promise<IntegrationTools>;
+    diagnostics(): Record<string, unknown>;
+}
+export declare function encodeSourceId(connectionId: string, projectId: string): string;
+export declare function decodeSourceId(sourceId: string): {
+    connectionId: string;
+    projectId: string;
+} | null;
+export declare function encodeIssueReference(reference: JiraIssueReference): string;
+export declare function decodeIssueReference(value: string): JiraIssueReference | null;
+export {};
+//# sourceMappingURL=integration.d.ts.map

package/dist/integrations/platform/jira/integration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../../../src/integrations/platform/jira/integration.ts"],"names":[],"mappings":"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"}

package/dist/integrations/platform/jira/integration.js

@@ -0,0 +1,540 @@
+import { PlatformApiClient, logPlatformInfo, platformApiClientConfigFromEnv } from "../api-client.js";
+import { IssueReconcileWorker } from "../../issue-reconcile-worker.js";
+import { adfToText } from "../../jira/adf.js";
+import { JiraApiClient, JiraApiError } from "../../jira/api.js";
+import { resolveJiraRules } from "../../jira/default-rules.js";
+import { attachJiraRules } from "../../jira/rules.js";
+import { attachJiraIssueReconciler } from "../../jira/issue-reconciler.js";
+import { jiraReconciliationEnabled, jiraReconciliationInterval } from "../../jira/reconciliation-config.js";
+import { buildPlatformJiraAgentTools } from "./agent-tools.js";
+import { buildPlatformJiraRoutes } from "./routes.js";
+//#region src/integrations/platform/jira/integration.ts
+const ISSUE_COMMENTS_MAX_PAGES = 20;
+/** Hard stop for project pagination so a misbehaving `isLast` can't loop forever. */
+const PROJECT_SEARCH_MAX_PAGES = 50;
+const ISSUE_KEY_PATTERN = /^[A-Za-z][A-Za-z0-9_]*-\d+$/;
+const PLATFORM_JIRA_PROVIDER_CONFIG_KEY = "jira";
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const JIRA_CONNECTION_TOKEN_PREFIX = "jira-connection:";
+const JIRA_ISSUE_REF_PREFIX = "jira-issue:";
+const JIRA_SOURCE_PREFIX = "jira-project:";
+const STATE_TYPE_TO_CATEGORY = {
+	unstarted: "new",
+	started: "indeterminate",
+	completed: "done"
+};
+function stateTypeFromCategory(key) {
+	switch (key) {
+		case "new": return "unstarted";
+		case "indeterminate": return "started";
+		case "done": return "completed";
+		default: return null;
+	}
+}
+var PlatformJiraIntegration = class {
+	id = "jira";
+	#clientConfig;
+	#platformClient;
+	#endpointHost;
+	#cloudIdByConnectionId = /* @__PURE__ */ new Map();
+	#siteUrlByConnectionId = /* @__PURE__ */ new Map();
+	#projects;
+	#auth;
+	#orgIdByResourceId = /* @__PURE__ */ new Map();
+	#rules;
+	get rules() {
+		return this.#rules;
+	}
+	constructor(config = {}) {
+		this.#rules = resolveJiraRules(config.rules);
+		this.#clientConfig = config.clientConfig ?? platformApiClientConfigFromEnv();
+		this.#platformClient = new PlatformApiClient(this.#clientConfig);
+		this.#endpointHost = new URL(this.#clientConfig.baseUrl).host;
+	}
+	initialize({ projects, auth }) {
+		this.#projects = projects;
+		this.#auth = auth;
+		logPlatformInfo("Platform Jira integration initialized", { endpointHost: this.#endpointHost });
+	}
+	get projects() {
+		if (!this.#projects) throw new Error("PlatformJiraIntegration is not initialized — the factory binds storage during prepare().");
+		return this.#projects;
+	}
+	get authEnabled() {
+		return this.#auth?.enabled() ?? false;
+	}
+	async resolveOrgId(resourceId) {
+		const cached = this.#orgIdByResourceId.get(resourceId);
+		if (cached !== void 0) return cached;
+		if (!UUID_PATTERN.test(resourceId)) {
+			this.#orgIdByResourceId.set(resourceId, null);
+			return null;
+		}
+		try {
+			await this.projects.ensureReady();
+			const orgId = (await this.projects.getById({ id: resourceId }))?.orgId ?? null;
+			this.#orgIdByResourceId.set(resourceId, orgId);
+			return orgId;
+		} catch {
+			return null;
+		}
+	}
+	clearCaches() {
+		this.#orgIdByResourceId.clear();
+		this.#cloudIdByConnectionId.clear();
+		this.#siteUrlByConnectionId.clear();
+	}
+	async listConnections() {
+		const providerKey = encodeURIComponent(PLATFORM_JIRA_PROVIDER_CONFIG_KEY);
+		return (await this.#platformClient.request("GET", `/v2/connections?providerKey=${providerKey}`)).connections;
+	}
+	async hasActiveConnections() {
+		return (await this.#activeConnections()).length > 0;
+	}
+	intake = {
+		resolveIntakeDispatch: (input) => this.#resolveIntakeDispatch(input),
+		listSources: () => this.#listSources(),
+		listItems: (input) => this.#listItems(input),
+		listIssues: (input) => this.#listIssues(input),
+		getIssue: (input) => this.#getIssue(input),
+		createComment: (input) => this.#createComment(input),
+		updateIssue: (input) => this.#updateIssue(input)
+	};
+	async #resolveIntakeDispatch({ externalSource }) {
+		if (externalSource.type !== "issue") return null;
+		const reference = decodeIssueReference(externalSource.externalId);
+		if (!reference) return null;
+		return {
+			connection: jiraConnection(reference.connectionId),
+			...reference.projectId ? { sourceId: encodeSourceId(reference.connectionId, reference.projectId) } : {},
+			issueId: reference.issueId
+		};
+	}
+	async #listSources() {
+		const sources = [];
+		for (const connection of await this.#activeConnections()) {
+			const context = await this.#connectionContext(connection);
+			let startAt = 0;
+			for (let pageCount = 0; pageCount < PROJECT_SEARCH_MAX_PAGES; pageCount++) {
+				const page = await context.api.listProjects({ startAt });
+				for (const project of page.values) sources.push({
+					id: encodeSourceId(connection.id, project.id),
+					name: project.name,
+					type: "project",
+					metadata: {
+						key: project.key,
+						connectionId: connection.id,
+						site: new URL(context.siteUrl).host
+					}
+				});
+				if (page.isLast || page.values.length === 0) break;
+				startAt += page.values.length;
+			}
+		}
+		return sources;
+	}
+	async #listItems({ sourceIds, cursor }) {
+		if (sourceIds.length === 0) return {
+			items: [],
+			nextCursor: null
+		};
+		const page = await this.listActiveIssues(cursor, sourceIds);
+		return {
+			items: page.issues.map((issue) => ({
+				source: {
+					type: "issue",
+					externalId: issue.externalId,
+					url: issue.url
+				},
+				sourceId: issue.sourceId,
+				title: `${issue.identifier}: ${issue.title}`,
+				status: issue.state ?? void 0,
+				labels: issue.labels,
+				assignee: issue.assignee,
+				createdAt: issue.createdAt,
+				updatedAt: issue.updatedAt,
+				metadata: {
+					identifier: issue.identifier,
+					issueRef: issue.externalId,
+					state: issue.state,
+					stateType: issue.stateType,
+					priority: issue.priority,
+					project: issue.source,
+					site: issue.site,
+					assignee: issue.assignee,
+					assignees: issue.assignees ?? [],
+					creator: issue.author,
+					author: issue.author,
+					labels: issue.labels,
+					createdAt: issue.createdAt,
+					updatedAt: issue.updatedAt
+				}
+			})),
+			nextCursor: page.nextCursor
+		};
+	}
+	async #listIssues(input) {
+		const page = await this.listActiveIssues(input.cursor, input.sourceIds, input.labels);
+		return {
+			issues: page.issues,
+			nextCursor: page.nextCursor
+		};
+	}
+	async listActiveIssues(cursor, sourceIds = [], labels) {
+		const grouped = groupSources(sourceIds);
+		if (grouped.length === 0) return {
+			issues: [],
+			nextCursor: null
+		};
+		const decodedCursor = decodePageCursor(cursor);
+		if (decodedCursor.group >= grouped.length) return {
+			issues: [],
+			nextCursor: null
+		};
+		for (let groupIndex = decodedCursor.group; groupIndex < grouped.length; groupIndex++) {
+			const group = grouped[groupIndex];
+			const context = await this.#connectionContextById(group.connectionId);
+			const jql = buildIntakeJql(group.projectIds, labels);
+			if (jql === null) continue;
+			const page = await context.api.searchIssues({
+				jql,
+				...groupIndex === decodedCursor.group && decodedCursor.jira ? { nextPageToken: decodedCursor.jira } : {}
+			});
+			const nextCursor = page.nextPageToken ? encodePageCursor({
+				group: groupIndex,
+				jira: page.nextPageToken
+			}) : groupIndex + 1 < grouped.length ? encodePageCursor({ group: groupIndex + 1 }) : null;
+			return {
+				issues: page.issues.map((issue) => {
+					const projectId = issue.fields.project?.id ?? group.projectIds[0] ?? "";
+					return {
+						...this.#toIntakeIssue(issue, context.siteUrl),
+						sourceId: encodeSourceId(group.connectionId, projectId),
+						externalId: encodeIssueReference({
+							connectionId: group.connectionId,
+							issueId: issue.key,
+							projectId
+						}),
+						site: new URL(context.siteUrl).host
+					};
+				}),
+				nextCursor
+			};
+		}
+		return {
+			issues: [],
+			nextCursor: null
+		};
+	}
+	async #getIssue(input) {
+		const { context, issue } = await this.#findIssue(input) ?? {};
+		if (!context || !issue) return null;
+		const { comments, total } = await this.#listAllComments(context.api, issue.key);
+		return {
+			...this.#toIntakeIssue(issue, context.siteUrl),
+			commentCount: total,
+			description: issue.fields.description ? adfToText(issue.fields.description) || null : null,
+			comments: comments.map((comment) => ({
+				author: comment.author?.displayName ?? null,
+				body: adfToText(comment.body),
+				createdAt: comment.created
+			}))
+		};
+	}
+	async #listAllComments(api, keyOrId) {
+		const comments = [];
+		let total = 0;
+		for (let page = 0; page < ISSUE_COMMENTS_MAX_PAGES; page++) {
+			const result = await api.listComments(keyOrId, { startAt: comments.length });
+			comments.push(...result.comments);
+			total = result.total;
+			if (result.comments.length === 0 || comments.length >= total) break;
+		}
+		return {
+			comments,
+			total
+		};
+	}
+	async #createComment(input) {
+		const resolved = await this.#resolveRequest(input);
+		let key = resolved.issueId;
+		if (!ISSUE_KEY_PATTERN.test(key)) try {
+			key = (await resolved.context.api.getIssue(key)).key;
+		} catch (error) {
+			if (error instanceof JiraApiError && error.status === 404) return null;
+			throw error;
+		}
+		const comment = await resolved.context.api.createComment(key, input.body);
+		return {
+			id: comment.id,
+			url: `${resolved.context.siteUrl}/browse/${key}?focusedCommentId=${comment.id}`
+		};
+	}
+	async #updateIssue(input) {
+		const resolved = await this.#resolveRequest(input);
+		let issue;
+		try {
+			issue = await resolved.context.api.getIssue(resolved.issueId);
+		} catch (error) {
+			if (error instanceof JiraApiError && error.status === 404) return null;
+			throw error;
+		}
+		if (currentStatusMatches(issue, input.state)) return this.#toIntakeIssue(issue, resolved.context.siteUrl);
+		const transition = resolveTransition(await resolved.context.api.listTransitions(issue.key), input.state);
+		if (!transition) return null;
+		await resolved.context.api.applyTransition(issue.key, transition.id);
+		return this.#toIntakeIssue(await resolved.context.api.getIssue(issue.key), resolved.context.siteUrl);
+	}
+	async #resolveRequest(input) {
+		const issueReference = decodeIssueReference(input.issueId);
+		const source = input.sourceId ? decodeSourceId(input.sourceId) : null;
+		const connectionId = issueReference?.connectionId ?? source?.connectionId ?? connectionIdFromConnection(input.connection);
+		const issueId = issueReference?.issueId ?? input.issueId;
+		if (connectionId) return {
+			context: await this.#connectionContextById(connectionId),
+			issueId
+		};
+		const active = await this.#activeConnections();
+		if (active.length !== 1) throw new JiraApiError("Jira issue reference must identify a connection when multiple sites are connected.", 400);
+		return {
+			context: await this.#connectionContext(active[0]),
+			issueId
+		};
+	}
+	/**
+	* Locate an issue for a read. A connection-scoped reference resolves
+	* directly; a plain issue key (the agent tool's normal input) is looked up
+	* across every active connection so multi-site organizations can still
+	* fetch by key — the first site that knows the key wins, which is safe
+	* because Jira project-key prefixes make cross-site collisions unlikely and
+	* the tool is read-only.
+	*/
+	async #findIssue(input) {
+		const issueReference = decodeIssueReference(input.issueId);
+		const source = input.sourceId ? decodeSourceId(input.sourceId) : null;
+		const connectionId = issueReference?.connectionId ?? source?.connectionId ?? connectionIdFromConnection(input.connection);
+		const issueId = issueReference?.issueId ?? input.issueId;
+		const candidates = [];
+		if (connectionId) candidates.push(await this.#connectionContextById(connectionId));
+		else {
+			const active = await this.#activeConnections();
+			if (active.length === 0) throw new JiraApiError("Jira connection is unavailable or requires reauthentication.", 401);
+			for (const connection of active) candidates.push(await this.#connectionContext(connection));
+		}
+		let firstError;
+		for (const context of candidates) try {
+			return {
+				context,
+				issue: await context.api.getIssue(issueId)
+			};
+		} catch (error) {
+			if (error instanceof JiraApiError && error.status === 404) continue;
+			firstError ??= error;
+		}
+		if (firstError !== void 0) throw firstError;
+		return null;
+	}
+	#toIntakeIssue(issue, siteUrl) {
+		const { fields } = issue;
+		return {
+			id: issue.id,
+			identifier: issue.key,
+			title: fields.summary ?? issue.key,
+			url: `${siteUrl}/browse/${issue.key}`,
+			author: fields.reporter?.displayName ?? null,
+			state: fields.status?.name ?? null,
+			stateType: stateTypeFromCategory(fields.status?.statusCategory?.key),
+			priority: fields.priority?.name ?? null,
+			assignee: fields.assignee?.displayName ?? null,
+			source: fields.project?.key ?? null,
+			labels: fields.labels ?? [],
+			commentCount: null,
+			createdAt: fields.created ?? "",
+			updatedAt: fields.updated ?? ""
+		};
+	}
+	async #activeConnections() {
+		return (await this.listConnections()).filter((connection) => connection.status === "active");
+	}
+	async #connectionContextById(connectionId) {
+		const connection = (await this.#activeConnections()).find((candidate) => candidate.id === connectionId);
+		if (!connection) throw new JiraApiError("Jira connection is unavailable or requires reauthentication.", 401);
+		return this.#connectionContext(connection);
+	}
+	async #cloudId(connectionId) {
+		const cached = this.#cloudIdByConnectionId.get(connectionId);
+		if (cached) return cached;
+		const cloudId = (await this.#platformClient.request("GET", `/v2/connections/${encodeURIComponent(connectionId)}/context`)).connection_config?.cloudId;
+		if (typeof cloudId !== "string" || !UUID_PATTERN.test(cloudId)) throw new JiraApiError("Platform Jira connection context is missing a valid cloudId.", 502);
+		this.#cloudIdByConnectionId.set(connectionId, cloudId);
+		return cloudId;
+	}
+	async #connectionContext(connection) {
+		const proxyBaseUrl = `${this.#clientConfig.baseUrl.replace(/\/+$/, "")}/v2/connections/${encodeURIComponent(connection.id)}/proxy`;
+		const cloudId = await this.#cloudId(connection.id);
+		const api = new JiraApiClient({
+			baseUrl: `${proxyBaseUrl}/ex/jira/${encodeURIComponent(cloudId)}`,
+			accessToken: this.#clientConfig.accessToken,
+			...this.#clientConfig.fetchImpl ? { fetchImpl: this.#clientConfig.fetchImpl } : {}
+		});
+		let siteUrl = this.#siteUrlByConnectionId.get(connection.id);
+		if (!siteUrl) {
+			siteUrl = connection.accountLabel ? normalizeSiteUrl(connection.accountLabel) : normalizeSiteUrl((await api.getServerInfo()).baseUrl);
+			this.#siteUrlByConnectionId.set(connection.id, siteUrl);
+		}
+		return {
+			connection,
+			api,
+			siteUrl
+		};
+	}
+	workers(ctx) {
+		if (!jiraReconciliationEnabled()) return [];
+		const reconcile = attachJiraIssueReconciler(this, ctx);
+		if (!reconcile) return [];
+		const intervalMs = jiraReconciliationInterval();
+		return [new IssueReconcileWorker({
+			integrationId: this.id,
+			reconcile,
+			...intervalMs ? { intervalMs } : {}
+		})];
+	}
+	routes(ctx) {
+		return buildPlatformJiraRoutes({
+			jira: this,
+			auth: ctx.auth,
+			intake: ctx.storage.intake,
+			appDbConfigured: Boolean(ctx.factoryStorage),
+			ingestFactoryIssues: attachJiraRules(this, ctx)
+		});
+	}
+	async agentTools(args) {
+		return buildPlatformJiraAgentTools({
+			requestContext: args.requestContext,
+			jira: this
+		});
+	}
+	diagnostics() {
+		return {
+			configured: true,
+			mode: "platform",
+			endpointHost: this.#endpointHost
+		};
+	}
+};
+function jiraConnection(connectionId) {
+	return {
+		type: "oauth",
+		accessToken: `${JIRA_CONNECTION_TOKEN_PREFIX}${connectionId}`
+	};
+}
+function connectionIdFromConnection(connection) {
+	if (connection.type !== "oauth" || !connection.accessToken.startsWith(JIRA_CONNECTION_TOKEN_PREFIX)) return null;
+	return connection.accessToken.slice(16) || null;
+}
+function encodeSourceId(connectionId, projectId) {
+	return `${JIRA_SOURCE_PREFIX}${Buffer.from(JSON.stringify({
+		connectionId,
+		projectId
+	})).toString("base64url")}`;
+}
+function decodeSourceId(sourceId) {
+	if (!sourceId.startsWith(JIRA_SOURCE_PREFIX)) return null;
+	try {
+		const parsed = JSON.parse(Buffer.from(sourceId.slice(13), "base64url").toString("utf8"));
+		return typeof parsed.connectionId === "string" && typeof parsed.projectId === "string" ? {
+			connectionId: parsed.connectionId,
+			projectId: parsed.projectId
+		} : null;
+	} catch {
+		return null;
+	}
+}
+function encodeIssueReference(reference) {
+	return `${JIRA_ISSUE_REF_PREFIX}${Buffer.from(JSON.stringify(reference)).toString("base64url")}`;
+}
+function decodeIssueReference(value) {
+	if (!value.startsWith(JIRA_ISSUE_REF_PREFIX)) return null;
+	try {
+		const parsed = JSON.parse(Buffer.from(value.slice(11), "base64url").toString("utf8"));
+		if (typeof parsed.connectionId !== "string" || typeof parsed.issueId !== "string") return null;
+		return {
+			connectionId: parsed.connectionId,
+			issueId: parsed.issueId,
+			...typeof parsed.projectId === "string" ? { projectId: parsed.projectId } : {}
+		};
+	} catch {
+		return null;
+	}
+}
+function groupSources(sourceIds) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const sourceId of sourceIds) {
+		const source = decodeSourceId(sourceId);
+		if (!source) continue;
+		const projectIds = groups.get(source.connectionId) ?? /* @__PURE__ */ new Set();
+		projectIds.add(source.projectId);
+		groups.set(source.connectionId, projectIds);
+	}
+	return [...groups.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([connectionId, projectIds]) => ({
+		connectionId,
+		projectIds: [...projectIds].sort()
+	}));
+}
+function encodePageCursor(cursor) {
+	return Buffer.from(JSON.stringify(cursor)).toString("base64url");
+}
+function decodePageCursor(cursor) {
+	if (!cursor) return { group: 0 };
+	try {
+		const parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+		if (!Number.isInteger(parsed.group) || parsed.group < 0) throw new Error();
+		return {
+			group: parsed.group,
+			...typeof parsed.jira === "string" ? { jira: parsed.jira } : {}
+		};
+	} catch {
+		throw new JiraApiError("Jira pagination cursor is invalid.", 400);
+	}
+}
+function normalizeSiteUrl(value) {
+	const candidate = /^https?:\/\//i.test(value) ? value : `https://${value}`;
+	let url;
+	try {
+		url = new URL(candidate);
+	} catch {
+		throw new JiraApiError("Jira site URL is invalid.", 502);
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new JiraApiError("Jira site URL is invalid.", 502);
+	return url.origin;
+}
+function buildIntakeJql(projectIds, labels) {
+	const clauses = [];
+	const safeProjects = (projectIds ?? []).map((id) => id.trim()).filter((id) => /^[A-Za-z0-9_]+$/.test(id)).map((id) => /^\d+$/.test(id) ? id : `"${id}"`);
+	if (projectIds && safeProjects.length === 0) return null;
+	if (safeProjects.length > 0) clauses.push(`project IN (${safeProjects.join(", ")})`);
+	clauses.push("statusCategory != Done");
+	const safeLabels = [...new Set((labels ?? []).map((label) => label.trim().replace(/["\\]/g, "")).filter(Boolean))];
+	if (safeLabels.length > 0) clauses.push(`labels IN (${safeLabels.map((label) => `"${label}"`).join(", ")})`);
+	return `${clauses.join(" AND ")} ORDER BY updated DESC`;
+}
+function currentStatusMatches(issue, target) {
+	const status = issue.fields.status;
+	if (!status) return false;
+	if (target.kind === "byName") return status.name.toLowerCase() === target.name.toLowerCase();
+	if (target.stateType === "canceled") return status.statusCategory?.key === "done" && /cancel/i.test(status.name);
+	return status.statusCategory?.key === STATE_TYPE_TO_CATEGORY[target.stateType];
+}
+function resolveTransition(transitions, target) {
+	if (target.kind === "byName") {
+		const wanted = target.name.toLowerCase();
+		return transitions.find((transition) => transition.to?.name.toLowerCase() === wanted) ?? null;
+	}
+	if (target.stateType === "canceled") return transitions.find((transition) => transition.to?.statusCategory?.key === "done" && /cancel/i.test(transition.to.name)) ?? null;
+	const category = STATE_TYPE_TO_CATEGORY[target.stateType];
+	return transitions.find((transition) => transition.to?.statusCategory?.key === category) ?? null;
+}
+//#endregion
+export { PlatformJiraIntegration, decodeIssueReference, decodeSourceId, encodeIssueReference, encodeSourceId };
+
+//# sourceMappingURL=integration.js.map