@mastra/factory 0.0.0-aggregate-trace-20261015182851

package/dist/integrations/gitlab/version-control.js

@@ -0,0 +1,621 @@
+import { GitLabApiError } from "./api.js";
+//#region src/integrations/gitlab/version-control.ts
+function buildGitLabVersionControl(deps) {
+	let storage;
+	const sourceControlStorage = () => {
+		if (!storage) throw new Error("GitLab VersionControl is not initialized.");
+		return storage;
+	};
+	const listPullRequests = async (input) => {
+		const context = await deps.contextForConnection(input.connection);
+		const page = parsePositiveCursor(input.cursor);
+		const state = input.state === "open" ? "opened" : input.state === "closed" ? "all" : input.state ?? "opened";
+		const mergeRequests = await context.api.listMergeRequests(input.sourceId, {
+			page,
+			state
+		});
+		return {
+			pullRequests: mergeRequests.filter((mergeRequest) => input.state !== "closed" || mergeRequest.state === "closed" || mergeRequest.state === "merged").filter((mergeRequest) => input.includeDrafts !== false || !isDraft(mergeRequest)).map(toPullRequest),
+			nextCursor: mergeRequests.length === 30 ? String(page + 1) : null
+		};
+	};
+	const getPullRequest = async (input) => {
+		const context = await deps.contextForConnection(input.connection);
+		try {
+			return toPullRequest(await context.api.getMergeRequest(input.sourceId, requirePositiveId(input.pullRequestId, "merge request")));
+		} catch (error) {
+			if (error instanceof GitLabApiError && error.status === 404) return null;
+			throw error;
+		}
+	};
+	const createPullRequest = async (input) => {
+		const context = await deps.contextForConnection(input.connection);
+		const title = input.draft && !/^(?:draft:|\[draft\])/i.test(input.title) ? `Draft: ${input.title}` : input.title;
+		return toPullRequest(await context.api.createMergeRequest(input.sourceId, {
+			sourceBranch: input.headBranch,
+			targetBranch: input.baseBranch,
+			title,
+			description: input.body
+		}));
+	};
+	const updatePullRequest = async (input) => {
+		return toPullRequest(await (await deps.contextForConnection(input.connection)).api.updateMergeRequest(input.sourceId, requirePositiveId(input.pullRequestId, "merge request"), {
+			title: input.title,
+			description: input.body === null ? "" : input.body,
+			targetBranch: input.baseBranch,
+			stateEvent: input.state === "closed" ? "close" : input.state === "open" ? "reopen" : void 0
+		}));
+	};
+	const closePullRequest = (input) => updatePullRequest({
+		...input,
+		state: "closed"
+	});
+	const mergePullRequest = async (input) => {
+		if (input.method === "rebase") throw notSupported("GitLab rebases merge requests asynchronously; rebase-and-merge is not supported.");
+		const context = await deps.contextForConnection(input.connection);
+		const commitMessage = combinedCommitMessage(input.commitTitle, input.commitMessage);
+		const result = await context.api.mergeMergeRequest(input.sourceId, requirePositiveId(input.pullRequestId, "merge request"), {
+			squash: input.method === "squash",
+			mergeCommitMessage: input.method === "squash" ? void 0 : commitMessage,
+			squashCommitMessage: input.method === "squash" ? commitMessage : void 0
+		});
+		const merged = result.state === "merged" || Boolean(result.merged_at);
+		return {
+			merged,
+			message: result.message ?? (merged ? "Merge request merged." : "Merge request was not merged."),
+			sha: result.squash_commit_sha ?? result.merge_commit_sha ?? result.sha ?? null
+		};
+	};
+	const listComments = async (input) => {
+		const context = await deps.contextForConnection(input.connection);
+		const mergeRequestIid = requirePositiveId(input.pullRequestId, "merge request");
+		const page = parsePositiveCursor(input.cursor);
+		const notes = await context.api.listMergeRequestNotes(input.sourceId, mergeRequestIid, { page });
+		return {
+			comments: notes.filter((note) => !note.system && note.type !== "DiffNote").map((note) => toPullRequestComment(webBaseUrl(context), input.sourceId, mergeRequestIid, note)),
+			nextCursor: notes.length === 100 ? String(page + 1) : null
+		};
+	};
+	const createComment = async (input) => {
+		const context = await deps.contextForConnection(input.connection);
+		const mergeRequestIid = requirePositiveId(input.pullRequestId, "merge request");
+		const note = await context.api.createMergeRequestNote(input.sourceId, mergeRequestIid, input.body);
+		return toPullRequestComment(webBaseUrl(context), input.sourceId, mergeRequestIid, note);
+	};
+	const updateComment = async (input) => {
+		const context = await deps.contextForConnection(input.connection);
+		const { mergeRequestIid, noteId } = parseNoteId(input.commentId);
+		const note = await context.api.updateMergeRequestNote(input.sourceId, mergeRequestIid, noteId, input.body);
+		return toPullRequestComment(webBaseUrl(context), input.sourceId, mergeRequestIid, note);
+	};
+	const deleteComment = async (input) => {
+		const context = await deps.contextForConnection(input.connection);
+		const { mergeRequestIid, noteId } = parseNoteId(input.commentId);
+		await context.api.deleteMergeRequestNote(input.sourceId, mergeRequestIid, noteId);
+	};
+	const listReviews = async (input) => {
+		const context = await deps.contextForConnection(input.connection);
+		const mergeRequestIid = requirePositiveId(input.pullRequestId, "merge request");
+		return {
+			reviews: ((await context.api.getMergeRequestApprovals(input.sourceId, mergeRequestIid)).approved_by ?? []).map(({ user }) => toApprovalReview(webBaseUrl(context), input.sourceId, mergeRequestIid, user)),
+			nextCursor: null
+		};
+	};
+	const getReview = async (input) => {
+		const mergeRequestIid = requirePositiveId(input.pullRequestId, "merge request");
+		const approvalPrefix = `${mergeRequestIid}:approval`;
+		const commentPrefix = `${mergeRequestIid}:comment:`;
+		if (input.reviewId !== approvalPrefix && !input.reviewId.startsWith(`${approvalPrefix}:`) && !input.reviewId.startsWith(commentPrefix)) return null;
+		const context = await deps.contextForConnection(input.connection);
+		if (input.reviewId === approvalPrefix || input.reviewId.startsWith(`${approvalPrefix}:`)) {
+			const reviewerKey = input.reviewId === approvalPrefix ? null : input.reviewId.slice(approvalPrefix.length + 1);
+			if (reviewerKey === "") return null;
+			const currentUser = reviewerKey === null ? await context.api.getCurrentUser() : null;
+			const user = ((await context.api.getMergeRequestApprovals(input.sourceId, mergeRequestIid)).approved_by ?? []).map((entry) => entry.user).find((candidate) => reviewerKey === null ? currentUser?.id !== void 0 && candidate.id === currentUser.id || candidate.username === currentUser?.username : String(candidate.id ?? candidate.username) === reviewerKey);
+			return user ? toApprovalReview(webBaseUrl(context), input.sourceId, mergeRequestIid, user) : null;
+		}
+		const noteId = parsePositiveInteger(input.reviewId.slice(commentPrefix.length));
+		if (noteId === null) return null;
+		try {
+			const note = await context.api.getMergeRequestNote(input.sourceId, mergeRequestIid, noteId);
+			if (note.system || note.type === "DiffNote") return null;
+			return toCommentReview(webBaseUrl(context), input.sourceId, mergeRequestIid, note);
+		} catch (error) {
+			if (error instanceof GitLabApiError && error.status === 404) return null;
+			throw error;
+		}
+	};
+	const createReview = async (input) => submitReviewAction(deps, {
+		connection: input.connection,
+		sourceId: input.sourceId,
+		pullRequestId: input.pullRequestId,
+		event: input.event,
+		body: input.body,
+		commitId: input.commitId
+	});
+	const updateReview = async () => {
+		throw notSupported("GitLab does not expose mutable pending review objects.");
+	};
+	const submitReview = async (input) => submitReviewAction(deps, {
+		connection: input.connection,
+		sourceId: input.sourceId,
+		pullRequestId: input.pullRequestId,
+		event: input.event,
+		body: input.body
+	});
+	const dismissReview = async () => {
+		throw notSupported("GitLab approval dismissal has no GitHub review equivalent.");
+	};
+	const deletePendingReview = async () => {
+		throw notSupported("GitLab does not expose pending review objects.");
+	};
+	const listReviewComments = async (input) => {
+		const context = await deps.contextForConnection(input.connection);
+		const mergeRequestIid = requirePositiveId(input.pullRequestId, "merge request");
+		const page = parsePositiveCursor(input.cursor);
+		const discussions = await context.api.listMergeRequestDiscussions(input.sourceId, mergeRequestIid, { page });
+		return {
+			comments: discussions.flatMap((discussion) => {
+				const position = discussionPosition(discussion.notes);
+				if (!position) return [];
+				const root = discussion.notes.find((note) => note.position) ?? discussion.notes[0];
+				const replyToId = root ? packDiscussionNoteId(mergeRequestIid, discussion.id, root.id) : null;
+				return discussion.notes.filter((note) => !note.system).map((note) => toReviewComment(webBaseUrl(context), input.sourceId, mergeRequestIid, discussion.id, note, note === root ? null : replyToId, position));
+			}),
+			nextCursor: discussions.length === 100 ? String(page + 1) : null
+		};
+	};
+	const createReviewComment = async (input) => {
+		const context = await deps.contextForConnection(input.connection);
+		const mergeRequestIid = requirePositiveId(input.pullRequestId, "merge request");
+		if (input.replyToId) {
+			const thread = parseReviewReplyId(input.replyToId);
+			if (thread.mergeRequestIid !== mergeRequestIid) throw new GitLabApiError("GitLab discussion does not belong to the requested merge request.", 400);
+			const discussion = await context.api.getMergeRequestDiscussion(input.sourceId, mergeRequestIid, thread.discussionId);
+			const position = discussionPosition(discussion.notes);
+			if (!position) throw new GitLabApiError("GitLab discussion is not anchored to a diff.", 400);
+			const root = discussion.notes.find((note) => note.position) ?? discussion.notes[0];
+			if (!root) throw new GitLabApiError("GitLab discussion response did not include a note.", 502);
+			const note = await context.api.addMergeRequestDiscussionNote(input.sourceId, mergeRequestIid, thread.discussionId, input.body);
+			return toReviewComment(webBaseUrl(context), input.sourceId, mergeRequestIid, thread.discussionId, note, packDiscussionNoteId(mergeRequestIid, thread.discussionId, root.id), position);
+		}
+		const mergeRequest = await context.api.getMergeRequest(input.sourceId, mergeRequestIid);
+		if (!mergeRequest.diff_refs) throw new GitLabApiError("GitLab merge request diff refs are not ready.", 409);
+		if (mergeRequest.diff_refs.head_sha !== input.commitId) throw new GitLabApiError("GitLab merge request changed since this review comment was prepared.", 409);
+		const { path, line, side } = input;
+		if (typeof path !== "string" || typeof line !== "number" || side !== "left" && side !== "right") throw new GitLabApiError("GitLab diff review comment position is invalid.", 400);
+		if (input.startLine === void 0 !== (input.startSide === void 0)) throw new GitLabApiError("A multi-line GitLab review comment requires both startLine and startSide.", 400);
+		const position = {
+			position_type: "text",
+			...mergeRequest.diff_refs,
+			old_path: path,
+			new_path: path,
+			old_line: side === "left" ? line : void 0,
+			new_line: side === "right" ? line : void 0,
+			...input.startLine !== void 0 && input.startSide ? { line_range: {
+				start: await discussionLine(path, input.startLine, input.startSide),
+				end: await discussionLine(path, line, side)
+			} } : {}
+		};
+		const discussion = await context.api.createMergeRequestDiscussion(input.sourceId, mergeRequestIid, {
+			body: input.body,
+			commitId: input.commitId,
+			position
+		});
+		const note = discussion.notes.find((candidate) => candidate.position) ?? discussion.notes[0];
+		if (!note) throw new GitLabApiError("GitLab discussion response did not include a note.", 502);
+		return toReviewComment(webBaseUrl(context), input.sourceId, mergeRequestIid, discussion.id, note, null, position);
+	};
+	const updateReviewComment = async (input) => {
+		const context = await deps.contextForConnection(input.connection);
+		const reference = parseDiscussionNoteId(input.commentId);
+		const discussion = await context.api.getMergeRequestDiscussion(input.sourceId, reference.mergeRequestIid, reference.discussionId);
+		const position = discussionPosition(discussion.notes);
+		if (!position) throw new GitLabApiError("GitLab discussion is not anchored to a diff.", 400);
+		const root = discussion.notes.find((candidate) => candidate.position) ?? discussion.notes[0];
+		if (!root) throw new GitLabApiError("GitLab discussion response did not include a note.", 502);
+		const note = await context.api.updateMergeRequestDiscussionNote(input.sourceId, reference.mergeRequestIid, reference.discussionId, reference.noteId, input.body);
+		return toReviewComment(webBaseUrl(context), input.sourceId, reference.mergeRequestIid, reference.discussionId, note, note.id === root.id ? null : packDiscussionNoteId(reference.mergeRequestIid, reference.discussionId, root.id), position);
+	};
+	const deleteReviewComment = async (input) => {
+		const context = await deps.contextForConnection(input.connection);
+		const reference = parseDiscussionNoteId(input.commentId);
+		await context.api.deleteMergeRequestDiscussionNote(input.sourceId, reference.mergeRequestIid, reference.discussionId, reference.noteId);
+	};
+	const resolveReviewThread = async (input) => {
+		const context = await deps.contextForConnection(input.connection);
+		const reference = parseDiscussionNoteId(input.commentId);
+		await context.api.resolveMergeRequestDiscussion(input.sourceId, reference.mergeRequestIid, reference.discussionId, input.resolved);
+	};
+	const listRequestedReviewers = async (input) => {
+		return toRequestedReviewers(await (await deps.contextForConnection(input.connection)).api.getMergeRequest(input.sourceId, requirePositiveId(input.pullRequestId, "merge request")));
+	};
+	const requestReviewers = async (input) => {
+		rejectTeamReviewers(input.teams);
+		const context = await deps.contextForConnection(input.connection);
+		const mergeRequestIid = requirePositiveId(input.pullRequestId, "merge request");
+		const mergeRequest = await context.api.getMergeRequest(input.sourceId, mergeRequestIid);
+		const requestedMembers = await resolveMembers(context.api, input.sourceId, input.users ?? []);
+		const currentIds = await reviewerIds(context.api, input.sourceId, mergeRequest.reviewers ?? []);
+		const reviewerIdsToSet = [.../* @__PURE__ */ new Set([...currentIds, ...requestedMembers.map((member) => member.id)])];
+		return toRequestedReviewers(await context.api.setMergeRequestReviewers(input.sourceId, mergeRequestIid, reviewerIdsToSet));
+	};
+	const removeRequestedReviewers = async (input) => {
+		rejectTeamReviewers(input.teams);
+		const context = await deps.contextForConnection(input.connection);
+		const mergeRequestIid = requirePositiveId(input.pullRequestId, "merge request");
+		const mergeRequest = await context.api.getMergeRequest(input.sourceId, mergeRequestIid);
+		const removals = new Set((input.users ?? []).map((username) => username.toLowerCase()));
+		const retained = (mergeRequest.reviewers ?? []).filter((user) => !removals.has(user.username.toLowerCase()));
+		const retainedIds = await reviewerIds(context.api, input.sourceId, retained);
+		return toRequestedReviewers(await context.api.setMergeRequestReviewers(input.sourceId, mergeRequestIid, retainedIds));
+	};
+	return {
+		initialize: (input) => {
+			storage = input.storage;
+		},
+		registerInstallation: async ({ orgId, userId, installation }) => {
+			const requestedConnection = parseConnection(installation.metadata?.connection);
+			if (!requestedConnection) throw new GitLabApiError("GitLab installation metadata must include a valid connection.", 400);
+			const context = await deps.contextForConnection(requestedConnection);
+			return sourceControlStorage().installations.upsert({
+				orgId,
+				connectedByUserId: userId,
+				externalId: installation.externalId,
+				accountName: installation.accountName,
+				accountType: installation.accountType,
+				providerMetadata: {
+					...installation.metadata,
+					connection: context.connection,
+					host: normalizeHost(context.host)
+				}
+			});
+		},
+		registerRepositories: async ({ orgId, installationId, repositories }) => {
+			const normalizedRepositories = repositories.map((repository) => ({
+				...repository,
+				slug: normalizeSlug(repository.slug)
+			}));
+			return await Promise.all(normalizedRepositories.map((repository) => sourceControlStorage().repositories.upsert({
+				orgId,
+				input: {
+					installationId,
+					externalId: repository.externalId,
+					slug: repository.slug,
+					defaultBranch: repository.defaultBranch,
+					providerMetadata: repository.metadata
+				}
+			})));
+		},
+		getRepositoryTarget: async ({ orgId, repositoryId }) => {
+			const repository = await sourceControlStorage().repositories.get({
+				orgId,
+				id: repositoryId
+			});
+			if (!repository) throw new Error("Version-control repository not found.");
+			const installation = await sourceControlStorage().installations.get({
+				orgId,
+				id: repository.installationId
+			});
+			if (!installation) throw new Error("Version-control installation not found.");
+			const connection = parseConnection(installation.providerMetadata.connection);
+			if (!connection) throw new GitLabApiError("GitLab installation connection metadata is invalid.", 500);
+			return {
+				connection: (await (deps.contextForStoredInstallation ?? deps.contextForConnection)(connection, typeof installation.providerMetadata.host === "string" ? installation.providerMetadata.host : void 0)).connection,
+				sourceId: `${repository.externalId}:${repository.slug}`
+			};
+		},
+		getRepositoryAccess: async ({ orgId, repositoryId }) => {
+			const repository = await sourceControlStorage().repositories.get({
+				orgId,
+				id: repositoryId
+			});
+			if (!repository) throw new Error("Version-control repository not found.");
+			const installation = await sourceControlStorage().installations.get({
+				orgId,
+				id: repository.installationId
+			});
+			if (!installation) throw new Error("Version-control installation not found.");
+			const connection = parseConnection(installation.providerMetadata.connection);
+			if (!connection) throw new GitLabApiError("GitLab installation connection metadata is invalid.", 500);
+			const context = await (deps.contextForStoredInstallation ?? deps.contextForConnection)(connection, typeof installation.providerMetadata.host === "string" ? installation.providerMetadata.host : void 0);
+			if (!context.repositoryAccessToken) throw notSupported("This GitLab connection does not expose credentials for repository cloning.");
+			const token = await context.repositoryAccessToken();
+			return {
+				cloneUrl: `${webBaseUrl(context)}/${normalizeSlug(repository.slug)}.git`,
+				authorization: {
+					scheme: "bearer",
+					token,
+					username: "oauth2"
+				}
+			};
+		},
+		listPullRequests,
+		getPullRequest,
+		createPullRequest,
+		updatePullRequest,
+		closePullRequest,
+		mergePullRequest,
+		listComments,
+		resolveReviewThread,
+		createComment,
+		updateComment,
+		deleteComment,
+		listReviews,
+		getReview,
+		createReview,
+		updateReview,
+		submitReview,
+		dismissReview,
+		deletePendingReview,
+		listReviewComments,
+		createReviewComment,
+		updateReviewComment,
+		deleteReviewComment,
+		listRequestedReviewers,
+		requestReviewers,
+		removeRequestedReviewers
+	};
+}
+async function submitReviewAction(deps, input) {
+	const context = await deps.contextForConnection(input.connection);
+	const mergeRequestIid = requirePositiveId(input.pullRequestId, "merge request");
+	if (input.event === "request-changes") throw notSupported("GitLab has no first-class request-changes review event.");
+	if (input.event === void 0) throw notSupported("GitLab has no first-class pending review object.");
+	if (input.event === "approve") {
+		const body = input.body?.trim();
+		await context.api.approveMergeRequest(input.sourceId, mergeRequestIid, input.commitId);
+		const comment = body ? toPullRequestComment(webBaseUrl(context), input.sourceId, mergeRequestIid, await context.api.createMergeRequestNote(input.sourceId, mergeRequestIid, body)) : null;
+		return {
+			id: String(mergeRequestIid) + ":approval",
+			url: comment?.url ?? mergeRequestUrl(webBaseUrl(context), input.sourceId, mergeRequestIid),
+			author: comment?.author ?? null,
+			body: comment?.body ?? null,
+			state: "approved",
+			commitId: null,
+			submittedAt: comment?.createdAt ?? null
+		};
+	}
+	const body = input.body?.trim();
+	if (!body) throw new GitLabApiError("GitLab comment reviews require a body.", 400);
+	const note = await context.api.createMergeRequestNote(input.sourceId, mergeRequestIid, body);
+	return toCommentReview(webBaseUrl(context), input.sourceId, mergeRequestIid, note);
+}
+function toCommentReview(host, sourceId, mergeRequestIid, note) {
+	const comment = toPullRequestComment(host, sourceId, mergeRequestIid, note);
+	return {
+		id: `${mergeRequestIid}:comment:${note.id}`,
+		url: comment.url,
+		author: comment.author,
+		body: comment.body,
+		state: "commented",
+		commitId: null,
+		submittedAt: note.created_at
+	};
+}
+function toApprovalReview(host, sourceId, mergeRequestIid, user) {
+	return {
+		id: `${mergeRequestIid}:approval:${user.id ?? user.username}`,
+		url: mergeRequestUrl(host, sourceId, mergeRequestIid),
+		author: displayName(user),
+		body: null,
+		state: "approved",
+		commitId: null,
+		submittedAt: null
+	};
+}
+function toReviewComment(host, sourceId, mergeRequestIid, discussionId, note, replyToId, fallbackPosition) {
+	const position = note.position ?? fallbackPosition;
+	if (!position) throw new GitLabApiError("GitLab review comment is missing its diff position.", 502);
+	const base = toPullRequestComment(host, sourceId, mergeRequestIid, note);
+	const side = position.new_line !== null && position.new_line !== void 0 ? "right" : "left";
+	return {
+		...base,
+		id: packDiscussionNoteId(mergeRequestIid, discussionId, note.id),
+		path: side === "right" ? position.new_path : position.old_path,
+		line: side === "right" ? position.new_line ?? null : position.old_line ?? null,
+		side,
+		commitId: position.head_sha,
+		replyToId
+	};
+}
+function mergeRequestUrl(host, sourceId, mergeRequestIid) {
+	return `${host}/${sourcePath(sourceId)}/-/merge_requests/${mergeRequestIid}`;
+}
+function webBaseUrl(context) {
+	const host = normalizeHost(context.host);
+	if (!context.webBaseUrl) return `https://${host}`;
+	let url;
+	try {
+		url = new URL(context.webBaseUrl);
+	} catch {
+		throw new GitLabApiError("GitLab web base URL is invalid.", 400);
+	}
+	const loopback = url.hostname === "localhost" || url.hostname === "[::1]" || /^127(?:\.\d{1,3}){3}$/.test(url.hostname);
+	if (url.host !== host || url.protocol !== "https:" && !(url.protocol === "http:" && loopback) || url.username || url.password || url.search || url.hash) throw new GitLabApiError("GitLab web base URL is invalid.", 400);
+	return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+}
+function sourcePath(sourceId) {
+	return normalizeSlug(/^\d+:(.+)$/.exec(sourceId)?.[1] ?? sourceId);
+}
+function packDiscussionId(mergeRequestIid, discussionId) {
+	if (!discussionId || discussionId.includes(":")) throw new GitLabApiError("GitLab discussion id is invalid.", 400);
+	return `${mergeRequestIid}:${discussionId}`;
+}
+function packDiscussionNoteId(mergeRequestIid, discussionId, noteId) {
+	return `${packDiscussionId(mergeRequestIid, discussionId)}:${noteId}`;
+}
+function parseReviewReplyId(value) {
+	const parts = value.split(":");
+	if (parts.length === 2) return parseDiscussionId(value);
+	if (parts.length === 3 && parts[1]) {
+		requirePositiveId(parts[2], "discussion note");
+		return {
+			mergeRequestIid: requirePositiveId(parts[0], "merge request"),
+			discussionId: parts[1]
+		};
+	}
+	throw new GitLabApiError("GitLab review reply id is invalid.", 400);
+}
+function parseDiscussionId(value) {
+	const parts = value.split(":");
+	if (parts.length !== 2 || !parts[1]) throw new GitLabApiError("GitLab discussion id is invalid.", 400);
+	return {
+		mergeRequestIid: requirePositiveId(parts[0], "merge request"),
+		discussionId: parts[1]
+	};
+}
+function parseDiscussionNoteId(value) {
+	const parts = value.split(":");
+	if (parts.length !== 3 || !parts[1]) throw new GitLabApiError("GitLab discussion note id is invalid.", 400);
+	return {
+		mergeRequestIid: requirePositiveId(parts[0], "merge request"),
+		discussionId: parts[1],
+		noteId: requirePositiveId(parts[2], "discussion note")
+	};
+}
+function discussionPosition(notes) {
+	return notes.find((note) => note.position)?.position ?? void 0;
+}
+async function discussionLine(path, line, side) {
+	const pathHash = Buffer.from(await globalThis.crypto.subtle.digest("SHA-1", new TextEncoder().encode(path))).toString("hex");
+	const oldLine = side === "left" ? line : void 0;
+	const newLine = side === "right" ? line : void 0;
+	return {
+		line_code: `${pathHash}_${oldLine ?? 0}_${newLine ?? 0}`,
+		type: side === "left" ? "old" : "new",
+		old_line: oldLine,
+		new_line: newLine
+	};
+}
+function toRequestedReviewers(mergeRequest) {
+	return {
+		users: (mergeRequest.reviewers ?? []).map((user) => user.username),
+		teams: []
+	};
+}
+async function resolveMembers(api, sourceId, usernames) {
+	return Promise.all(usernames.map((username) => resolveMember(api, sourceId, username)));
+}
+async function resolveMember(api, sourceId, username) {
+	const normalized = username.trim();
+	if (!normalized) throw new GitLabApiError("GitLab reviewer username is invalid.", 400);
+	const member = (await api.listProjectMembers(sourceId, { query: normalized })).find((candidate) => candidate.username.toLowerCase() === normalized.toLowerCase());
+	if (!member) throw new GitLabApiError(`GitLab reviewer ${normalized} is not a project member.`, 404);
+	return member;
+}
+async function reviewerIds(api, sourceId, users) {
+	return Promise.all(users.map(async (user) => user.id ?? (await resolveMember(api, sourceId, user.username)).id));
+}
+function rejectTeamReviewers(teams) {
+	if (!teams?.length) return;
+	throw notSupported("GitLab merge requests do not have a direct team-reviewer equivalent.");
+}
+function notSupported(message) {
+	return new GitLabApiError(message, 501);
+}
+function toPullRequest(mergeRequest) {
+	return {
+		id: String(mergeRequest.iid),
+		title: mergeRequest.title,
+		url: mergeRequest.web_url,
+		author: displayName(mergeRequest.author),
+		assignees: mergeRequest.assignees?.map((user) => user.username),
+		requestedReviewers: mergeRequest.reviewers?.map((user) => user.username),
+		labels: mergeRequest.labels,
+		body: mergeRequest.description?.trim() ? mergeRequest.description : null,
+		state: mergeRequest.state === "closed" || mergeRequest.state === "merged" ? "closed" : "open",
+		draft: isDraft(mergeRequest),
+		merged: mergeRequest.state === "merged" || Boolean(mergeRequest.merged_at),
+		mergeable: mergeableState(mergeRequest.merge_status),
+		baseBranch: mergeRequest.target_branch,
+		headBranch: mergeRequest.source_branch,
+		headSha: mergeRequest.sha,
+		createdAt: mergeRequest.created_at,
+		updatedAt: mergeRequest.updated_at
+	};
+}
+function toPullRequestComment(host, sourceId, mergeRequestIid, note) {
+	return {
+		id: `${mergeRequestIid}:${note.id}`,
+		url: `${mergeRequestUrl(host, sourceId, mergeRequestIid)}#note_${note.id}`,
+		author: displayName(note.author),
+		body: note.body,
+		createdAt: note.created_at,
+		updatedAt: note.updated_at ?? note.created_at
+	};
+}
+function displayName(user) {
+	return user?.username || user?.name?.trim() || null;
+}
+function isDraft(mergeRequest) {
+	return mergeRequest.draft ?? mergeRequest.work_in_progress ?? /^(?:draft:|\[draft\])/i.test(mergeRequest.title);
+}
+function mergeableState(status) {
+	if (status === "can_be_merged") return true;
+	if (status === "cannot_be_merged") return false;
+	return null;
+}
+function combinedCommitMessage(title, body) {
+	const parts = [title?.trim(), body?.trim()].filter((part) => Boolean(part));
+	return parts.length > 0 ? parts.join("\n\n") : void 0;
+}
+function parseNoteId(value) {
+	const parts = value.split(":");
+	if (parts.length !== 2) throw new GitLabApiError("GitLab merge request note id is invalid.", 400);
+	return {
+		mergeRequestIid: requirePositiveId(parts[0], "merge request"),
+		noteId: requirePositiveId(parts[1], "note")
+	};
+}
+function parsePositiveCursor(cursor) {
+	if (cursor === void 0) return 1;
+	const page = parsePositiveInteger(cursor);
+	if (page === null) throw new GitLabApiError("GitLab cursor must be a positive page number.", 400);
+	return page;
+}
+function requirePositiveId(value, resource) {
+	const parsed = parsePositiveInteger(value);
+	if (parsed === null) throw new GitLabApiError(`GitLab ${resource} id must be a positive integer.`, 400);
+	return parsed;
+}
+function parsePositiveInteger(value) {
+	if (!/^\d+$/.test(value)) return null;
+	const parsed = Number(value);
+	return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
+}
+function parseConnection(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const connection = value;
+	if (connection.type === "oauth" && typeof connection.accessToken === "string" && connection.accessToken.length > 0) return {
+		type: "oauth",
+		accessToken: connection.accessToken
+	};
+	if (connection.type === "app-installation" && Number.isSafeInteger(connection.installationId) && Number(connection.installationId) > 0) return {
+		type: "app-installation",
+		installationId: Number(connection.installationId)
+	};
+	return null;
+}
+function normalizeHost(value) {
+	const host = value.trim();
+	if (!host || host.includes("/") || host.includes("@")) throw new GitLabApiError("GitLab host is invalid.", 400);
+	let parsed;
+	try {
+		parsed = new URL(`https://${host}`);
+	} catch {
+		throw new GitLabApiError("GitLab host is invalid.", 400);
+	}
+	if (parsed.host !== host) throw new GitLabApiError("GitLab host is invalid.", 400);
+	return host;
+}
+function normalizeSlug(value) {
+	const slug = value.replace(/^\/+|\/+$/g, "");
+	const segments = slug.split("/");
+	if (!slug || segments.some((segment) => !/^[A-Za-z0-9_.-]+$/.test(segment) || segment === "." || segment === "..")) throw new GitLabApiError("GitLab repository slug is invalid.", 400);
+	return slug;
+}
+//#endregion
+export { buildGitLabVersionControl };
+
+//# sourceMappingURL=version-control.js.map