@ucdjs/release-scripts 0.1.0-beta.31 → 0.1.0-beta.32

package/dist/index.d.mts

@@ -35,6 +35,9 @@ interface ReleaseScriptsOptionsInput {
     otp?: string;
     provenance?: boolean;
   };
+  prompts?: {
+    versions?: boolean;
+  };
 }
 //#endregion
 //#region src/services/workspace.service.d.ts

package/dist/index.mjs

@@ -7,6 +7,7 @@ import * as CommitParser from "commit-parser";
 import process from "node:process";
 import semver from "semver";
 import fs from "node:fs/promises";
+import prompts from "prompts";
 
 //#region src/utils/changelog-formatters.ts
 const eta$1 = new Eta();
@@ -243,23 +244,25 @@ const DEFAULT_TYPES = {
 	}
 };
 function normalizeReleaseScriptsOptions(options) {
-	const { workspaceRoot = process.cwd(), githubToken = "", repo: fullRepo, packages = true, branch = {}, globalCommitMode = "dependencies", pullRequest = {}, changelog = {}, types = {}, dryRun = false, npm = {} } = options;
+	const { workspaceRoot = process.cwd(), githubToken = "", repo: fullRepo, packages = true, branch = {}, globalCommitMode = "dependencies", pullRequest = {}, changelog = {}, types = {}, dryRun = false, npm = {}, prompts = {} } = options;
 	const token = githubToken.trim();
 	if (!token) throw new Error("GitHub token is required. Pass it in via options.");
 	if (!fullRepo || !fullRepo.trim() || !fullRepo.includes("/")) throw new Error("Repository (repo) is required. Specify in 'owner/repo' format (e.g., 'octocat/hello-world').");
 	const [owner, repo] = fullRepo.split("/");
 	if (!owner || !repo) throw new Error(`Invalid repo format: "${fullRepo}". Expected format: "owner/repo" (e.g., "octocat/hello-world").`);
+	const normalizedPackages = typeof packages === "object" && !Array.isArray(packages) ? {
+		exclude: packages.exclude ?? [],
+		include: packages.include ?? [],
+		excludePrivate: packages.excludePrivate ?? false
+	} : packages;
+	const isCI = process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true";
 	return {
 		dryRun,
 		workspaceRoot,
 		githubToken: token,
 		owner,
 		repo,
-		packages: typeof packages === "object" && !Array.isArray(packages) ? {
-			exclude: packages.exclude ?? [],
-			include: packages.include ?? [],
-			excludePrivate: packages.excludePrivate ?? false
-		} : packages,
+		packages: normalizedPackages,
 		branch: {
 			release: branch.release ?? "release/next",
 			default: branch.default ?? "main"
@@ -281,7 +284,8 @@ function normalizeReleaseScriptsOptions(options) {
 		npm: {
 			otp: npm.otp,
 			provenance: npm.provenance ?? true
-		}
+		},
+		prompts: { versions: prompts.versions ?? !isCI }
 	};
 }
 var ReleaseScriptsOptions = class extends Context.Tag("@ucdjs/release-scripts/ReleaseScriptsOptions")() {};
@@ -1003,6 +1007,275 @@ var VersionCalculatorService = class extends Effect.Service()("@ucdjs/release-sc
 	dependencies: []
 }) {};
 
+//#endregion
+//#region src/services/version-prompt.service.ts
+function formatCommit(commit) {
+	const typeEmoji = getTypeEmoji(commit.type);
+	const scope = commit.scope ? `(${commit.scope})` : "";
+	const breaking = commit.isBreaking ? "!" : "";
+	const header = commit.isConventional ? `${typeEmoji} ${commit.type}${scope}${breaking}: ${commit.description}` : commit.message.split("\n")[0] ?? commit.message;
+	const refs = commit.references.map((r) => r.type === "pull-request" ? `#${r.value}` : `#${r.value}`).join(" ");
+	return refs ? `${header} (${refs})` : header;
+}
+function getTypeEmoji(type) {
+	return {
+		feat: "✨",
+		fix: "🐛",
+		docs: "📚",
+		style: "💎",
+		refactor: "🔧",
+		perf: "🏎️",
+		test: "🧪",
+		build: "📦",
+		ci: "👷",
+		chore: "🔧",
+		revert: "⏪"
+	}[type] || "📝";
+}
+function formatCommits(commits) {
+	if (commits.length === 0) return "  No commits since the last version";
+	return commits.slice(0, 10).map((c) => `  ${formatCommit(c)}`).join("\n") + (commits.length > 10 ? `\n  ... and ${commits.length - 10} more` : "");
+}
+function getPrereleaseInfo(version) {
+	const parsed = semver.parse(version);
+	if (!parsed) return null;
+	if (parsed.prerelease.length === 0) return null;
+	return {
+		identifier: String(parsed.prerelease[0]),
+		baseVersion: `${parsed.major}.${parsed.minor}.${parsed.patch}`
+	};
+}
+function generateVersionOptions(currentVersion, conventionalBump, prereleaseInfo) {
+	const options = [];
+	const majorVersion = semver.inc(currentVersion, "major");
+	const minorVersion = semver.inc(currentVersion, "minor");
+	const patchVersion = semver.inc(currentVersion, "patch");
+	if (majorVersion) options.push({
+		title: `major ${majorVersion}`,
+		value: {
+			version: majorVersion,
+			bumpType: "major"
+		}
+	});
+	if (minorVersion) options.push({
+		title: `minor ${minorVersion}`,
+		value: {
+			version: minorVersion,
+			bumpType: "minor"
+		}
+	});
+	if (patchVersion) options.push({
+		title: `patch ${patchVersion}`,
+		value: {
+			version: patchVersion,
+			bumpType: "patch"
+		}
+	});
+	if (prereleaseInfo) {
+		const nextPrerelease = semver.inc(currentVersion, "prerelease", prereleaseInfo.identifier);
+		if (nextPrerelease) options.push({
+			title: `next ${nextPrerelease}`,
+			value: {
+				version: nextPrerelease,
+				bumpType: "patch"
+			}
+		});
+	}
+	const conventionalVersion = conventionalBump !== "none" ? semver.inc(currentVersion, conventionalBump) : currentVersion;
+	if (conventionalVersion && conventionalVersion !== currentVersion) options.push({
+		title: `conventional ${conventionalVersion}`,
+		value: {
+			version: conventionalVersion,
+			bumpType: conventionalBump
+		}
+	});
+	if (prereleaseInfo) {
+		const prePatch = semver.inc(currentVersion, "prepatch", prereleaseInfo.identifier);
+		const preMinor = semver.inc(currentVersion, "preminor", prereleaseInfo.identifier);
+		const preMajor = semver.inc(currentVersion, "premajor", prereleaseInfo.identifier);
+		if (prePatch) options.push({
+			title: `pre-patch ${prePatch}`,
+			value: {
+				version: prePatch,
+				bumpType: "patch"
+			}
+		});
+		if (preMinor) options.push({
+			title: `pre-minor ${preMinor}`,
+			value: {
+				version: preMinor,
+				bumpType: "minor"
+			}
+		});
+		if (preMajor) options.push({
+			title: `pre-major ${preMajor}`,
+			value: {
+				version: preMajor,
+				bumpType: "major"
+			}
+		});
+	} else {
+		const betaPatch = semver.inc(currentVersion, "prepatch", "beta");
+		const betaMinor = semver.inc(currentVersion, "preminor", "beta");
+		const betaMajor = semver.inc(currentVersion, "premajor", "beta");
+		if (betaPatch) options.push({
+			title: `pre-patch ${betaPatch}`,
+			value: {
+				version: betaPatch,
+				bumpType: "patch"
+			}
+		});
+		if (betaMinor) options.push({
+			title: `pre-minor ${betaMinor}`,
+			value: {
+				version: betaMinor,
+				bumpType: "minor"
+			}
+		});
+		if (betaMajor) options.push({
+			title: `pre-major ${betaMajor}`,
+			value: {
+				version: betaMajor,
+				bumpType: "major"
+			}
+		});
+	}
+	options.push({
+		title: `as-is ${currentVersion}`,
+		value: {
+			version: currentVersion,
+			bumpType: "none"
+		}
+	});
+	options.push({
+		title: "custom ...",
+		value: {
+			version: "custom",
+			bumpType: "none"
+		}
+	});
+	return options;
+}
+async function promptForCustomVersion(currentVersion) {
+	return (await prompts({
+		type: "text",
+		name: "version",
+		message: `Enter custom version (current: ${currentVersion})`,
+		validate: (input) => {
+			if (!semver.valid(input)) return "Please enter a valid semver version (e.g., 1.2.3)";
+			return true;
+		}
+	})).version || null;
+}
+var VersionPromptService = class extends Effect.Service()("@ucdjs/release-scripts/VersionPromptService", {
+	effect: Effect.gen(function* () {
+		const config = yield* ReleaseScriptsOptions;
+		let applyToAllRemainingChoice = null;
+		function promptForVersion(pkg, conventionalBump, remainingCount) {
+			return Effect.async((resume) => {
+				const allCommits = [...pkg.commits, ...pkg.globalCommits];
+				const prereleaseInfo = getPrereleaseInfo(pkg.version);
+				console.log("");
+				console.log(`\x1B[1m${pkg.name}\x1B[0m`);
+				console.log(`Current version: ${pkg.version}`);
+				console.log("");
+				console.log("Commits:");
+				console.log(formatCommits(allCommits));
+				console.log("");
+				if (applyToAllRemainingChoice) {
+					const result = {
+						newVersion: applyToAllRemainingChoice.version === "custom" ? pkg.version : applyToAllRemainingChoice.version,
+						bumpType: applyToAllRemainingChoice.bumpType,
+						applyToAllRemaining: false
+					};
+					resume(Effect.succeed(result));
+					return;
+				}
+				const options = generateVersionOptions(pkg.version, conventionalBump, prereleaseInfo);
+				if (remainingCount > 1) options.push({
+					title: "apply-to-all ›",
+					value: {
+						version: "apply-to-all",
+						bumpType: "none"
+					}
+				});
+				prompts({
+					type: "select",
+					name: "choice",
+					message: `Select version`,
+					choices: options.map((o) => ({
+						title: o.title,
+						value: o.value
+					})),
+					hint: "Use arrow keys to navigate, enter to select"
+				}).then(async (response) => {
+					if (!response.choice) {
+						const result = {
+							newVersion: pkg.version,
+							bumpType: "none",
+							applyToAllRemaining: false
+						};
+						resume(Effect.succeed(result));
+						return;
+					}
+					if (response.choice.version === "apply-to-all") {
+						const applyOptions = options.filter((o) => o.value.version !== "custom" && o.value.version !== "apply-to-all");
+						const applyResponse = await prompts({
+							type: "select",
+							name: "choice",
+							message: `Apply to all ${remainingCount} remaining packages`,
+							choices: applyOptions.map((o) => ({
+								title: o.title,
+								value: o.value
+							}))
+						});
+						if (applyResponse.choice) {
+							if (applyResponse.choice.version === "custom") {
+								const customVersion = await promptForCustomVersion(pkg.version);
+								if (customVersion) applyToAllRemainingChoice = {
+									version: customVersion,
+									bumpType: applyResponse.choice.bumpType
+								};
+							} else applyToAllRemainingChoice = applyResponse.choice;
+							const result = {
+								newVersion: applyToAllRemainingChoice?.version || pkg.version,
+								bumpType: applyToAllRemainingChoice?.bumpType || "none",
+								applyToAllRemaining: true
+							};
+							resume(Effect.succeed(result));
+						} else promptForVersion(pkg, conventionalBump, remainingCount).pipe(Effect.runPromise).then((r) => resume(Effect.succeed(r)));
+						return;
+					}
+					let selectedVersion = response.choice.version;
+					let selectedBumpType = response.choice.bumpType;
+					if (selectedVersion === "custom") {
+						const customVersion = await promptForCustomVersion(pkg.version);
+						if (customVersion) selectedVersion = customVersion;
+						else {
+							selectedVersion = pkg.version;
+							selectedBumpType = "none";
+						}
+					}
+					const result = {
+						newVersion: selectedVersion,
+						bumpType: selectedBumpType,
+						applyToAllRemaining: false
+					};
+					resume(Effect.succeed(result));
+				});
+			});
+		}
+		return {
+			promptForVersion,
+			isEnabled: config.prompts.versions,
+			resetApplyToAll: () => {
+				applyToAllRemainingChoice = null;
+			}
+		};
+	}),
+	dependencies: []
+}) {};
+
 //#endregion
 //#region src/utils/helpers.ts
 function loadOverrides(options) {
@@ -1197,6 +1470,7 @@ function constructPrepareProgram(config) {
 		const dependencyGraph = yield* DependencyGraphService;
 		const packageUpdater = yield* PackageUpdaterService;
 		const versionCalculator = yield* VersionCalculatorService;
+		const versionPrompt = yield* VersionPromptService;
 		const workspace = yield* WorkspaceService;
 		yield* git.workspace.assertWorkspaceReady;
 		let releasePullRequest = yield* github.getPullRequestByBranch(config.branch.release);
@@ -1225,10 +1499,56 @@ function constructPrepareProgram(config) {
 		yield* git.branches.checkout(config.branch.default);
 		const packages = yield* workspace.discoverWorkspacePackages.pipe(Effect.flatMap(mergePackageCommitsIntoPackages), Effect.flatMap((pkgs) => mergeCommitsAffectingGloballyIntoPackage(pkgs, config.globalCommitMode)));
 		yield* Console.log(`📦 Discovered ${packages.length} packages with commits.`);
-		const releases = yield* versionCalculator.calculateBumps(packages, overrides);
 		yield* dependencyGraph.topologicalOrder(packages);
+		const releases = [];
+		if (versionPrompt.isEnabled) {
+			yield* Console.log("\n🎯 Interactive version selection enabled.\n");
+			versionPrompt.resetApplyToAll();
+			for (let i = 0; i < packages.length; i++) {
+				const pkg = packages[i];
+				const conventionalBump = determineBump([...pkg.commits, ...pkg.globalCommits]);
+				const remainingCount = packages.length - i;
+				const override = overrides[pkg.name];
+				if (override) {
+					if (!semver.valid(override)) return yield* Effect.fail(/* @__PURE__ */ new Error(`Invalid override version for ${pkg.name}: ${override}`));
+					releases.push({
+						package: {
+							name: pkg.name,
+							version: pkg.version,
+							path: pkg.path,
+							packageJson: pkg.packageJson,
+							workspaceDependencies: pkg.workspaceDependencies,
+							workspaceDevDependencies: pkg.workspaceDevDependencies
+						},
+						currentVersion: pkg.version,
+						newVersion: override,
+						bumpType: "none",
+						hasDirectChanges: pkg.commits.length > 0
+					});
+					continue;
+				}
+				const result = yield* versionPrompt.promptForVersion(pkg, conventionalBump, remainingCount);
+				releases.push({
+					package: {
+						name: pkg.name,
+						version: pkg.version,
+						path: pkg.path,
+						packageJson: pkg.packageJson,
+						workspaceDependencies: pkg.workspaceDependencies,
+						workspaceDevDependencies: pkg.workspaceDevDependencies
+					},
+					currentVersion: pkg.version,
+					newVersion: result.newVersion,
+					bumpType: result.bumpType,
+					hasDirectChanges: pkg.commits.length > 0
+				});
+			}
+		} else {
+			const calculatedReleases = yield* versionCalculator.calculateBumps(packages, overrides);
+			releases.push(...calculatedReleases);
+		}
 		const releasesCount = releases.length;
-		yield* Console.log(`📊 ${releasesCount} package${releasesCount === 1 ? "" : "s"} will be released.`);
+		yield* Console.log(`\n📊 ${releasesCount} package${releasesCount === 1 ? "" : "s"} will be released.`);
 		yield* git.branches.checkout(originalBranch);
 		yield* Console.log("✏️  Updating package.json files...");
 		yield* packageUpdater.applyReleases(packages, releases);
@@ -1283,6 +1603,8 @@ ${releases.map((r) => `  - ${r.package.name}@${r.newVersion}`).join("\n")}`;
 			yield* Console.log("✅ Pull request updated.");
 		}
 		yield* Console.log(`\n🎉 Release preparation complete! View PR: #${releasePullRequest.number}`);
+		yield* git.branches.checkout(config.branch.default);
+		yield* Console.log(`✅ Switched back to "${config.branch.default}".`);
 	});
 }
 
@@ -1511,7 +1833,7 @@ function constructVerifyProgram(config) {
 //#region src/index.ts
 async function createReleaseScripts(options) {
 	const config = normalizeReleaseScriptsOptions(options);
-	const AppLayer = Layer.mergeAll(ChangelogService.Default, GitService.Default, GitHubService.Default, DependencyGraphService.Default, NPMService.Default, PackageUpdaterService.Default, VersionCalculatorService.Default, WorkspaceService.Default).pipe(Layer.provide(Layer.succeed(ReleaseScriptsOptions, config)), Layer.provide(NodeCommandExecutor.layer), Layer.provide(NodeFileSystem.layer));
+	const AppLayer = Layer.mergeAll(ChangelogService.Default, GitService.Default, GitHubService.Default, DependencyGraphService.Default, NPMService.Default, PackageUpdaterService.Default, VersionCalculatorService.Default, VersionPromptService.Default, WorkspaceService.Default).pipe(Layer.provide(Layer.succeed(ReleaseScriptsOptions, config)), Layer.provide(NodeCommandExecutor.layer), Layer.provide(NodeFileSystem.layer));
 	const runProgram = (program) => {
 		const provided = program.pipe(Effect.provide(AppLayer));
 		return Effect.runPromise(provided);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ucdjs/release-scripts",
-  "version": "0.1.0-beta.31",
+  "version": "0.1.0-beta.32",
   "description": "@ucdjs release scripts",
   "type": "module",
   "license": "MIT",