@overdeck/desktop 0.45.23 → 0.46.0

package/server/merge-completeness-BMm8tMyZ.js

@@ -0,0 +1,277 @@
+import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
+import { r as init_project_repos, s as resolveProjectReposForIssueSync } from "./project-repos-C0nuoBGv.js";
+import { a as patchMergeSetRepoSync, i as init_merge_set, n as ensureMergeSetForIssueSync, o as patchMergeSetReposSync, r as getMergeSetSync } from "./merge-set-DH7ot3yz.js";
+import { n as getForgeAdapter, r as init_forge } from "./forge-CZbSg6Ds.js";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+//#region ../../lib/cloister/merge-completeness.ts
+function shellQuote(value) {
+	return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function errorMessage(error) {
+	if (!(error instanceof Error)) return String(error);
+	const stderr = "stderr" in error ? String(error.stderr || "") : "";
+	return `${error.message} ${stderr}`.trim();
+}
+function isMissingSourceBranch(error, sourceBranch) {
+	const message = errorMessage(error);
+	return message.includes("couldn't find remote ref") && message.includes(sourceBranch);
+}
+async function fetchBranches(repo) {
+	try {
+		await execAsync(`git fetch origin ${shellQuote(repo.sourceBranch)} ${shellQuote(repo.targetBranch)}`, {
+			cwd: repo.repoPath,
+			encoding: "utf-8",
+			timeout: 3e4
+		});
+		return true;
+	} catch (error) {
+		if (!isMissingSourceBranch(error, repo.sourceBranch)) throw error;
+		await execAsync(`git fetch origin ${shellQuote(repo.targetBranch)}`, {
+			cwd: repo.repoPath,
+			encoding: "utf-8",
+			timeout: 3e4
+		});
+		return false;
+	}
+}
+function resolveRepos(issueId, labels) {
+	const mergeSet = ensureMergeSetForIssueSync(issueId, labels);
+	return {
+		mergeSet,
+		repos: mergeSet?.repos ?? resolveProjectReposForIssueSync(issueId, labels)
+	};
+}
+function buildSummary(repos, complete) {
+	if (repos.length === 0) return "Merge completeness is unverifiable because no repositories resolved";
+	if (complete) return `Merge complete across ${repos.length} ${repos.length === 1 ? "repository" : "repositories"}`;
+	return repos.filter((repo) => repo.state === "unmerged" || repo.state === "unverifiable").map((repo) => repo.reason).join("; ");
+}
+async function assessRepoMergeCompleteness(repo) {
+	if (!repo.required) return {
+		repoKey: repo.repoKey,
+		state: "no-changes",
+		aheadCount: 0,
+		reason: `${repo.repoKey} is readonly and not required for merge completeness`
+	};
+	try {
+		if (!await fetchBranches(repo)) return {
+			repoKey: repo.repoKey,
+			state: "no-changes",
+			aheadCount: 0,
+			reason: `${repo.repoKey} source branch ${repo.sourceBranch} does not exist on origin`
+		};
+		const { stdout } = await execAsync(`git rev-list --count origin/${shellQuote(repo.targetBranch)}..origin/${shellQuote(repo.sourceBranch)}`, {
+			cwd: repo.repoPath,
+			encoding: "utf-8",
+			timeout: 3e4
+		});
+		const aheadCount = Number.parseInt(stdout.trim(), 10);
+		if (!Number.isFinite(aheadCount) || aheadCount < 0) throw new Error(`Invalid ahead count: ${stdout.trim()}`);
+		if (aheadCount === 0) return {
+			repoKey: repo.repoKey,
+			state: "no-changes",
+			aheadCount,
+			reason: `${repo.repoKey} has no commits ahead of ${repo.targetBranch}`
+		};
+		const artifactInput = {
+			sourceBranch: repo.sourceBranch,
+			cwd: repo.repoPath
+		};
+		if (repo.forge === "gitlab") {
+			const { stdout: headStdout } = await execAsync(`git rev-parse ${shellQuote(`origin/${repo.sourceBranch}`)}`, {
+				cwd: repo.repoPath,
+				encoding: "utf-8",
+				timeout: 1e4
+			});
+			const headSha = headStdout.trim();
+			if (!headSha) throw new Error(`Unable to resolve origin/${repo.sourceBranch}`);
+			Object.assign(artifactInput, {
+				targetBranch: repo.targetBranch,
+				headSha,
+				artifactUrl: repo.artifactUrl,
+				artifactId: repo.artifactId
+			});
+		}
+		const artifact = await getForgeAdapter(repo.forge).findMergedArtifact(artifactInput);
+		if (artifact) return {
+			repoKey: repo.repoKey,
+			state: "merged",
+			aheadCount,
+			artifactUrl: artifact.url,
+			artifactId: artifact.id,
+			reason: repo.forge === "gitlab" ? `${repo.repoKey} has a merged review artifact for the current ${repo.sourceBranch} head` : `${repo.repoKey} has a merged review artifact for ${repo.sourceBranch}`
+		};
+		return {
+			repoKey: repo.repoKey,
+			state: "unmerged",
+			aheadCount,
+			reason: `${repo.repoKey} has ${aheadCount} commits on ${repo.sourceBranch} ahead of ${repo.targetBranch} with no merged review artifact`
+		};
+	} catch (error) {
+		return {
+			repoKey: repo.repoKey,
+			state: "unverifiable",
+			aheadCount: 0,
+			reason: `${repo.repoKey} merge state is unverifiable: ${errorMessage(error)}`
+		};
+	}
+}
+function hasPositiveMergedEvidence(repos) {
+	return repos.some((repo) => repo.state === "merged");
+}
+async function assessMergeCompleteness(issueId, labels = []) {
+	const resolved = resolveRepos(issueId, labels);
+	if (!resolved.repos || resolved.repos.length === 0) {
+		const repos = [];
+		return {
+			complete: false,
+			repos,
+			summary: buildSummary(repos, false)
+		};
+	}
+	const repos = await Promise.all(resolved.repos.map(assessRepoMergeCompleteness));
+	const complete = repos.every((repo) => repo.state === "merged" || repo.state === "no-changes");
+	return {
+		complete,
+		repos,
+		summary: buildSummary(repos, complete)
+	};
+}
+async function observeForgeMergeState(issueId, labels = []) {
+	const resolved = resolveRepos(issueId, labels);
+	if (!resolved.repos || resolved.repos.length === 0) {
+		const repos = [];
+		return {
+			complete: false,
+			hasPositiveMergedEvidence: false,
+			mergeSet: resolved.mergeSet,
+			repos,
+			summary: buildSummary(repos, false)
+		};
+	}
+	const repos = await Promise.all(resolved.repos.map(assessRepoMergeCompleteness));
+	let mergeSet = resolved.mergeSet;
+	if (mergeSet && !repos.some((repo) => repo.state === "unverifiable")) {
+		for (let index = 0; index < repos.length; index += 1) {
+			const result = repos[index];
+			if (result.state !== "merged" || !result.artifactUrl) continue;
+			const observed = mergeSet.repos.find((repo) => repo.repoKey === result.repoKey);
+			const artifactMatches = observed?.artifactUrl === result.artifactUrl && (result.artifactId === void 0 || observed.artifactId === result.artifactId);
+			if (observed?.mergeStatus === "merged" && artifactMatches) continue;
+			if (!(observed && patchMergeSetRepoSync(issueId, result.repoKey, observed, {
+				artifactId: result.artifactId,
+				artifactUrl: result.artifactUrl,
+				mergeStatus: "merged"
+			}))) repos[index] = {
+				...result,
+				state: "unverifiable",
+				reason: `${result.repoKey} merge-set row changed during forge observation; retrying on the next patrol`
+			};
+		}
+		mergeSet = getMergeSetSync(issueId) ?? mergeSet;
+	}
+	const complete = repos.every((repo) => repo.state === "merged" || repo.state === "no-changes");
+	return {
+		complete,
+		hasPositiveMergedEvidence: hasPositiveMergedEvidence(repos),
+		mergeSet,
+		repos,
+		summary: buildSummary(repos, complete)
+	};
+}
+async function reconcileStrandedRepos(initialMergeSet) {
+	const issueId = initialMergeSet.issueId;
+	let mergeSet = getMergeSetSync(issueId) ?? initialMergeSet;
+	const blockers = [];
+	const plannedPatches = /* @__PURE__ */ new Map();
+	const planPatch = (observed, patch) => {
+		const existing = plannedPatches.get(observed.repoKey);
+		plannedPatches.set(observed.repoKey, existing ? {
+			...existing,
+			patch: {
+				...existing.patch,
+				...patch
+			}
+		} : {
+			repoKey: observed.repoKey,
+			expected: observed,
+			patch
+		});
+		mergeSet = {
+			...mergeSet,
+			repos: mergeSet.repos.map((repo) => repo.repoKey === observed.repoKey ? {
+				...repo,
+				...patch
+			} : repo)
+		};
+	};
+	const stranded = mergeSet.repos.filter((repo) => repo.required && repo.mergeStatus !== "skipped" && !repo.artifactUrl);
+	for (const repo of stranded) {
+		try {
+			const discovered = await getForgeAdapter(repo.forge).discoverArtifact({
+				sourceBranch: repo.sourceBranch,
+				cwd: repo.repoPath
+			});
+			if (discovered?.url) {
+				planPatch(repo, {
+					artifactUrl: discovered.url,
+					artifactId: discovered.id
+				});
+				continue;
+			}
+		} catch (error) {
+			blockers.push({
+				repoKey: repo.repoKey,
+				state: "unverifiable",
+				aheadCount: 0,
+				reason: `${repo.repoKey} artifact discovery is unverifiable: ${errorMessage(error)}`
+			});
+			continue;
+		}
+		const result = await assessRepoMergeCompleteness(repo);
+		if (result.state === "no-changes") planPatch(repo, { mergeStatus: "skipped" });
+		else if (result.state === "merged" && result.artifactUrl) planPatch(repo, {
+			artifactId: result.artifactId,
+			artifactUrl: result.artifactUrl,
+			mergeStatus: "merged"
+		});
+		else if (result.state === "unmerged" || result.state === "unverifiable") blockers.push(result);
+	}
+	const candidates = mergeSet.repos.filter((repo) => repo.required && repo.mergeStatus !== "skipped" && Boolean(repo.artifactUrl) && (repo.mergeStatus === "pending" || repo.mergeStatus === "failed" || repo.mergeStatus === "merging"));
+	for (const repo of candidates) {
+		const result = await assessRepoMergeCompleteness(repo);
+		if (result.state === "merged" && result.artifactUrl) planPatch(repo, {
+			artifactId: result.artifactId,
+			artifactUrl: result.artifactUrl,
+			mergeStatus: "merged"
+		});
+		else if (result.state === "unverifiable") blockers.push(result);
+	}
+	if (blockers.some((blocker) => blocker.state === "unverifiable")) return {
+		mergeSet: getMergeSetSync(issueId) ?? initialMergeSet,
+		blockers
+	};
+	const patches = [...plannedPatches.values()];
+	if (patches.length > 0 && !patchMergeSetReposSync(issueId, patches)) blockers.push({
+		repoKey: patches.map((entry) => entry.repoKey).join(", "),
+		state: "unverifiable",
+		aheadCount: 0,
+		reason: "Merge-set rows changed during merge reconciliation; retry the merge"
+	});
+	return {
+		mergeSet: getMergeSetSync(issueId) ?? mergeSet,
+		blockers
+	};
+}
+var execAsync;
+var init_merge_completeness = __esmMin((() => {
+	init_forge();
+	init_merge_set();
+	init_project_repos();
+	execAsync = promisify(exec);
+}));
+//#endregion
+export { observeForgeMergeState as a, init_merge_completeness as i, assessRepoMergeCompleteness as n, reconcileStrandedRepos as o, hasPositiveMergedEvidence as r, assessMergeCompleteness as t };
+
+//# sourceMappingURL=merge-completeness-BMm8tMyZ.js.map

package/server/merge-completeness-D0ljXbk3.js

@@ -0,0 +1,3 @@
+import { a as observeForgeMergeState, i as init_merge_completeness, n as assessRepoMergeCompleteness, o as reconcileStrandedRepos } from "./merge-completeness-BMm8tMyZ.js";
+init_merge_completeness();
+export { assessRepoMergeCompleteness, observeForgeMergeState, reconcileStrandedRepos };

package/server/{merge-DK23JEdS.js → merge-idOG--29.js}

@@ -1,2 +1,2 @@
-import { A as UatNotPromotable, B as readyForMerge, C as RepoMergeStatus, D as UatMember, E as UatGenerationNotFound, F as enqueueMerge, I as getAllActiveQueues, L as getCurrentMerge, M as UatStatus, N as WorkspaceType, O as UatMemberRole, P as dequeueMerge, R as getQueueForProject, S as RepoKey, T as UatGenerationFilter, _ as NotReadyForMerge, a as ForgeMergeFailed, b as QueueView, c as MergeInProgress, d as MergeSet, f as MergeSetNotFound, g as MergeWriterLive, h as MergeWriter, i as AutoMergeStatus, j as UatResolution, k as UatName, l as MergeResolver, m as MergeSetStatus, n as AutoMergeFilter, o as GateStatus, p as MergeSetRepo, r as AutoMergeNotFound, s as MergeApi, t as AutoMerge, u as MergeResolverLive, v as ProjectKey, w as UatGeneration, x as RebaseStatus, y as QueueEntryStatus, z as markMergeProcessing } from "./merge-C_ZEhbqI.js";
+import { A as UatNotPromotable, B as readyForMerge, C as RepoMergeStatus, D as UatMember, E as UatGenerationNotFound, F as enqueueMerge, I as getAllActiveQueues, L as getCurrentMerge, M as UatStatus, N as WorkspaceType, O as UatMemberRole, P as dequeueMerge, R as getQueueForProject, S as RepoKey, T as UatGenerationFilter, _ as NotReadyForMerge, a as ForgeMergeFailed, b as QueueView, c as MergeInProgress, d as MergeSet, f as MergeSetNotFound, g as MergeWriterLive, h as MergeWriter, i as AutoMergeStatus, j as UatResolution, k as UatName, l as MergeResolver, m as MergeSetStatus, n as AutoMergeFilter, o as GateStatus, p as MergeSetRepo, r as AutoMergeNotFound, s as MergeApi, t as AutoMerge, u as MergeResolverLive, v as ProjectKey, w as UatGeneration, x as RebaseStatus, y as QueueEntryStatus, z as markMergeProcessing } from "./merge-Bpx4jjht.js";
 export { AutoMerge, AutoMergeFilter, AutoMergeNotFound, AutoMergeStatus, ForgeMergeFailed, GateStatus, MergeApi, MergeInProgress, MergeResolver, MergeResolverLive, MergeSet, MergeSetNotFound, MergeSetRepo, MergeSetStatus, MergeWriter, MergeWriterLive, NotReadyForMerge, ProjectKey, QueueEntryStatus, QueueView, RebaseStatus, RepoKey, RepoMergeStatus, UatGeneration, UatGenerationFilter, UatGenerationNotFound, UatMember, UatMemberRole, UatName, UatNotPromotable, UatResolution, UatStatus, WorkspaceType, dequeueMerge, enqueueMerge, getAllActiveQueues, getCurrentMerge, getQueueForProject, markMergeProcessing, readyForMerge };

package/server/merge-ops-DdpTiEMt.js

@@ -0,0 +1,2 @@
+import { c as triggerMerge } from "./workspaces-j1e_6aAT.js";
+export { triggerMerge };

package/server/merge-rebase-DGQpYJU3.js

@@ -0,0 +1,2 @@
+import { t as rebaseFeatureBranch } from "./merge-rebase-xLnMlw5h.js";
+export { rebaseFeatureBranch };

package/server/{merge-rebase-C1KIVr0s.js → merge-rebase-xLnMlw5h.js}

@@ -1,4 +1,4 @@
-import { ar as GitError, lr as MergeConflictError, mr as init_errors } from "./config-yaml-DvyMuOle.js";
+import { Ar as MergeConflictError, Er as GitError, Fr as init_errors } from "./config-yaml-CmOPzmBb.js";
 import { Effect } from "effect";
 import { existsSync } from "fs";
 import { join } from "path";
@@ -129,6 +129,6 @@ function rebaseFeatureBranch(workspacePath, featureBranch, baseBranch, issueId)
 	});
 }
 //#endregion
-export { rebaseFeatureBranch };
+export { rebaseFeatureBranch as t };
 
-//# sourceMappingURL=merge-rebase-C1KIVr0s.js.map
+//# sourceMappingURL=merge-rebase-xLnMlw5h.js.map

package/server/merge-set-DH7ot3yz.js

@@ -0,0 +1,89 @@
+import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
+import { Gn as init_projects, ar as resolveProjectFromIssueSync, br as resolveIssueIdSync, gr as init_issue_id } from "./config-yaml-CmOPzmBb.js";
+import { o as getMergeSetFromDb, s as init_merge_sync, v as patchMergeSetRepo, w as upsertMergeSet, y as patchMergeSetRepos } from "./merge-sync-CQ-LgZ1_.js";
+import { c as resolveProjectReposFromResolvedIssueSync, r as init_project_repos } from "./project-repos-C0nuoBGv.js";
+import "effect";
+//#region ../../lib/merge-set.ts
+function upsertMergeSetSync(mergeSet) {
+	upsertMergeSet({
+		...mergeSet,
+		issueId: resolveIssueIdSync(mergeSet.issueId)
+	});
+}
+function getMergeSetSync(issueId) {
+	return getMergeSetFromDb(resolveIssueIdSync(issueId));
+}
+function buildMergeSetForIssueSync(issueId, labels = []) {
+	const resolved = resolveProjectFromIssueSync(issueId, labels);
+	if (!resolved) return null;
+	const repos = resolveProjectReposFromResolvedIssueSync(issueId, resolved);
+	if (!repos) return null;
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		issueId,
+		projectKey: resolved.projectKey,
+		projectPath: resolved.projectPath,
+		workspaceType: repos.length > 1 ? "polyrepo" : "monorepo",
+		status: "draft",
+		createdAt: now,
+		updatedAt: now,
+		repos: repos.map((repo) => ({
+			repoKey: repo.repoKey,
+			repoPath: repo.repoPath,
+			forge: repo.forge,
+			sourceBranch: repo.sourceBranch,
+			targetBranch: repo.targetBranch,
+			reviewStatus: "pending",
+			testStatus: "pending",
+			rebaseStatus: "pending",
+			verificationStatus: "pending",
+			mergeStatus: "pending",
+			mergeOrder: repo.mergeOrder,
+			required: repo.required
+		}))
+	};
+}
+function ensureMergeSetForIssueSync(issueId, labels = []) {
+	const existing = getMergeSetSync(issueId);
+	if (existing) return existing;
+	const built = buildMergeSetForIssueSync(issueId, labels);
+	if (built) upsertMergeSetSync(built);
+	return built;
+}
+function withRepoArtifactUrlSync(mergeSet, repoKey, artifactUrl, artifactId) {
+	return {
+		...mergeSet,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		repos: mergeSet.repos.map((repo) => repo.repoKey === repoKey ? {
+			...repo,
+			artifactUrl,
+			artifactId
+		} : repo)
+	};
+}
+function withRepoStateSync(mergeSet, repoKey, patch) {
+	return {
+		...mergeSet,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		repos: mergeSet.repos.map((repo) => repo.repoKey === repoKey ? {
+			...repo,
+			...patch
+		} : repo)
+	};
+}
+function patchMergeSetRepoSync(issueId, repoKey, expected, patch) {
+	return patchMergeSetRepo(resolveIssueIdSync(issueId), repoKey, expected, patch);
+}
+function patchMergeSetReposSync(issueId, patches) {
+	return patchMergeSetRepos(resolveIssueIdSync(issueId), patches);
+}
+var init_merge_set = __esmMin((() => {
+	init_merge_sync();
+	init_projects();
+	init_project_repos();
+	init_issue_id();
+}));
+//#endregion
+export { patchMergeSetRepoSync as a, withRepoArtifactUrlSync as c, init_merge_set as i, withRepoStateSync as l, ensureMergeSetForIssueSync as n, patchMergeSetReposSync as o, getMergeSetSync as r, upsertMergeSetSync as s, buildMergeSetForIssueSync as t };
+
+//# sourceMappingURL=merge-set-DH7ot3yz.js.map

package/server/merge-set-DzsOTBg5.js

@@ -0,0 +1,3 @@
+import { c as withRepoArtifactUrlSync, i as init_merge_set, l as withRepoStateSync, n as ensureMergeSetForIssueSync, r as getMergeSetSync, s as upsertMergeSetSync } from "./merge-set-DH7ot3yz.js";
+init_merge_set();
+export { ensureMergeSetForIssueSync, getMergeSetSync, upsertMergeSetSync, withRepoArtifactUrlSync, withRepoStateSync };