chore: ensure release starts from main branch

Author: r0b1n

automation/utils/bin/rui-prepare-release.ts

@@ -5,7 +5,7 @@ import { bumpPackageJson, bumpXml, getNextVersion } from "../src/bump-version";
 import { exec } from "../src/shell";
 import { gh } from "../src/github";
 import { printGithubAuthHelp } from "../src/cli-utils";
-import { printPkgInformation, selectPackageV2 } from "../src/prepare-release-helpers";
+import { printPkgInformation, selectPackageV2, ensureMainBranch } from "../src/prepare-release-helpers";
 
 async function main(): Promise<void> {
     try {
@@ -22,6 +22,9 @@ async function main(): Promise<void> {
             process.exit(1);
         }
 
+        // Check git branch: must be on main and in sync with origin/main
+        await ensureMainBranch();
+
         // Step 1: Initialize Jira client
         let jira: Jira | undefined;
         try {

automation/utils/src/prepare-release-helpers.ts

@@ -7,8 +7,8 @@ import {
 } from "./changelog-parser";
 import { listPackages, PackageListing } from "./monorepo";
 import chalk from "chalk";
-
 import { prompt } from "enquirer";
+import { exec } from "./shell";
 
 type WidgetPkg = {
     type: "widget";
@@ -123,6 +123,107 @@ function createPackagesTree(map: PackagesFullInfoMap, list: PackagesFullInfoList
     return tree;
 }
 
+async function getCurrentBranch(): Promise<string> {
+    const { stdout } = await exec("git rev-parse --abbrev-ref HEAD", { stdio: "pipe" });
+    return stdout.trim();
+}
+
+async function getRemoteSyncCounts(): Promise<{ behind: number; ahead: number }> {
+    const [{ stdout: behindStr }, { stdout: aheadStr }] = await Promise.all([
+        exec("git rev-list HEAD..origin/main --count", { stdio: "pipe" }),
+        exec("git rev-list origin/main..HEAD --count", { stdio: "pipe" })
+    ]);
+    return {
+        behind: parseInt(behindStr.trim(), 10),
+        ahead: parseInt(aheadStr.trim(), 10)
+    };
+}
+
+async function switchToMain(): Promise<void> {
+    const { confirmSwitch } = await prompt<{ confirmSwitch: boolean }>({
+        type: "confirm",
+        name: "confirmSwitch",
+        message: `❓ Switch to ${chalk.blue("main")} branch?`,
+        initial: true
+    });
+
+    if (!confirmSwitch) {
+        console.log(chalk.red("❌ Release preparation must start from the main branch"));
+        process.exit(1);
+    }
+
+    await exec("git checkout main", { stdio: "pipe" });
+    console.log(chalk.green("✅ Switched to main"));
+}
+
+async function fastForwardMain(): Promise<void> {
+    const { confirmFastForward } = await prompt<{ confirmFastForward: boolean }>({
+        type: "confirm",
+        name: "confirmFastForward",
+        message: `❓ Fast-forward ${chalk.blue("main")} to ${chalk.blue("origin/main")}?`,
+        initial: true
+    });
+
+    if (!confirmFastForward) {
+        console.log(chalk.yellow("⚠️  Continuing with an outdated main branch"));
+        return;
+    }
+
+    await exec("git merge --ff-only origin/main", { stdio: "pipe" });
+    console.log(chalk.green("✅ main fast-forwarded to origin/main"));
+}
+
+export async function ensureMainBranch(): Promise<void> {
+    const branch = await getCurrentBranch();
+
+    if (branch !== "main") {
+        console.log(chalk.yellow(`⚠️  Current branch is ${chalk.blue(branch)}, expected ${chalk.blue("main")}`));
+        await switchToMain();
+    }
+
+    console.log(chalk.blue("🔄 Fetching origin/main..."));
+    await exec("git fetch origin main", { stdio: "pipe" });
+
+    const { behind, ahead } = await getRemoteSyncCounts();
+
+    if (behind === 0 && ahead === 0) {
+        console.log(chalk.green("✅ main is up to date with origin/main"));
+        return;
+    }
+
+    if (behind > 0 && ahead === 0) {
+        console.log(chalk.yellow(`⚠️  main is ${behind} commit(s) behind origin/main`));
+        await fastForwardMain();
+        return;
+    }
+
+    if (ahead > 0 && behind === 0) {
+        console.log(
+            chalk.yellow(`⚠️  main is ${ahead} commit(s) ahead of origin/main (unpushed local commits detected)`)
+        );
+        console.log(chalk.yellow("   Proceeding, but consider pushing or resetting before releasing."));
+        return;
+    }
+
+    // Truly diverged: both sides have unique commits
+    console.log(chalk.red(`❌ main has diverged from origin/main: ${ahead} ahead, ${behind} behind`));
+    console.log(chalk.red("   You may need to reset or rebase before creating a release."));
+
+    const { continueAnyway } = await prompt<{ continueAnyway: boolean }>({
+        type: "confirm",
+        name: "continueAnyway",
+        message: "❓ Continue anyway? (not recommended)",
+        initial: false
+    });
+
+    if (!continueAnyway) {
+        console.log(chalk.red("❌ Release preparation canceled"));
+        process.exit(1);
+    }
+
+    console.log(chalk.yellow("⚠️  Continuing with a diverged main branch"));
+}
+
 export async function selectPackageV2(): Promise<WidgetPkg | ModulePkg> {
     const pkgs = await listPackages(['"*"', '"!web-widgets"']);
     const pkgsList = await loadPackagesFullInfo(pkgs);