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

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,281 @@ var VersionCalculatorService = class extends Effect.Service()("@ucdjs/release-sc
 	dependencies: []
 }) {};
 
+//#endregion
+//#region src/services/version-prompt.service.ts
+const GREY = "\x1B[90m";
+const RESET = "\x1B[0m";
+const NON_VERSIONING_TYPES = new Set([
+	"chore",
+	"docs",
+	"style",
+	"test",
+	"ci",
+	"build",
+	"refactor"
+]);
+function isVersioningCommit(commit) {
+	return !NON_VERSIONING_TYPES.has(commit.type) || commit.isBreaking;
+}
+function formatCommit(commit) {
+	const isGreyed = !isVersioningCommit(commit);
+	const scope = commit.scope ? `(${commit.scope})` : "";
+	const description = commit.isConventional ? commit.description : commit.message.split("\n")[0] ?? commit.message;
+	const line = `${commit.shortHash}  ${commit.type.padEnd(12)}${scope.padEnd(10)}: ${description}`;
+	return isGreyed ? `${GREY}${line}${RESET}` : line;
+}
+function formatCommits(commits) {
+	if (commits.length === 0) return "  No commits since the last version";
+	const lines = commits.slice(0, 10).map((c) => `  ${formatCommit(c)}`);
+	if (commits.length > 10) lines.push(`  ${GREY}... and ${commits.length - 10} more${RESET}`);
+	return lines.join("\n");
+}
+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) : null;
+	if (conventionalVersion) 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;
+}
+function findDefaultIndex(options, conventionalBump) {
+	if (conventionalBump === "none") return 0;
+	const conventionalIndex = options.findIndex((o) => o.title.startsWith("conventional"));
+	return conventionalIndex >= 0 ? conventionalIndex : 0;
+}
+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);
+				const commitCount = allCommits.length;
+				console.log("");
+				console.log(`${commitCount} commit${commitCount === 1 ? "" : "s"} since the last version:`);
+				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);
+				const defaultIndex = findDefaultIndex(options, conventionalBump);
+				if (remainingCount > 1) options.push({
+					title: "apply-to-all ›",
+					value: {
+						version: "apply-to-all",
+						bumpType: "none"
+					}
+				});
+				prompts({
+					type: "select",
+					name: "choice",
+					message: `Current version ${pkg.version}`,
+					choices: options.map((o) => ({
+						title: o.title,
+						value: o.value
+					})),
+					initial: defaultIndex,
+					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
+							})),
+							initial: findDefaultIndex(applyOptions, conventionalBump)
+						});
+						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,43 +1476,90 @@ 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);
 		const isNewRelease = !releasePullRequest;
 		const branchExists = yield* git.branches.exists(config.branch.release);
 		if (!branchExists) {
-			yield* Console.log(`🌿 Creating release branch "${config.branch.release}" from "${config.branch.default}"...`);
+			yield* Console.log(`Creating release branch "${config.branch.release}" from "${config.branch.default}"...`);
 			yield* git.branches.create(config.branch.release, config.branch.default);
-			yield* Console.log(`✅ Release branch created.`);
+			yield* Console.log(`Release branch created.`);
 		}
 		if ((yield* git.branches.get) !== config.branch.release) {
 			yield* git.branches.checkout(config.branch.release);
-			yield* Console.log(`✅ Checked out to release branch "${config.branch.release}".`);
+			yield* Console.log(`Checked out to release branch "${config.branch.release}".`);
 		}
 		if (!isNewRelease || branchExists) {
-			yield* Console.log(`🔄 Rebasing "${config.branch.release}" onto "${config.branch.default}"...`);
+			yield* Console.log(`Rebasing "${config.branch.release}" onto "${config.branch.default}"...`);
 			yield* git.branches.rebase(config.branch.default);
-			yield* Console.log(`✅ Rebase complete.`);
+			yield* Console.log(`Rebase complete.`);
 		}
 		const overrides = yield* loadOverrides({
 			sha: config.branch.default,
 			overridesPath: ".github/ucdjs-release.overrides.json"
 		});
-		if (Object.keys(overrides).length > 0) yield* Console.log("📋 Loaded version overrides:", overrides);
+		if (Object.keys(overrides).length > 0) yield* Console.log("Loaded version overrides:", overrides);
 		const originalBranch = yield* git.branches.get;
 		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* Console.log(`Discovered ${packages.length} packages with commits.`);
 		yield* dependencyGraph.topologicalOrder(packages);
+		const releases = [];
+		if (versionPrompt.isEnabled) {
+			yield* Console.log("\nInteractive 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* Console.log("Updating package.json files...");
 		yield* packageUpdater.applyReleases(packages, releases);
-		yield* Console.log("✅ package.json files updated.");
-		yield* Console.log("📝 Generating changelogs...");
+		yield* Console.log("package.json files updated.");
+		yield* Console.log("Generating changelogs...");
 		const changelogFiles = [];
 		for (const release of releases) {
 			const pkg = packages.find((p) => p.name === release.package.name);
@@ -1247,28 +1573,28 @@ function constructPrepareProgram(config) {
 			});
 			changelogFiles.push(result.filePath);
 		}
-		yield* Console.log(`✅ Generated ${changelogFiles.length} changelog file${changelogFiles.length === 1 ? "" : "s"}.`);
+		yield* Console.log(`Generated ${changelogFiles.length} changelog file${changelogFiles.length === 1 ? "" : "s"}.`);
 		const filesToStage = [...releases.map((r) => `${r.package.path}/package.json`), ...changelogFiles];
-		yield* Console.log(`📌 Staging ${filesToStage.length} file${filesToStage.length === 1 ? "" : "s"}...`);
+		yield* Console.log(`Staging ${filesToStage.length} file${filesToStage.length === 1 ? "" : "s"}...`);
 		yield* git.commits.stage(filesToStage);
 		const commitMessage = `chore(release): prepare release
 
 ${releasesCount} package${releasesCount === 1 ? "" : "s"} updated:
 ${releases.map((r) => `  - ${r.package.name}@${r.newVersion}`).join("\n")}`;
-		yield* Console.log("💾 Creating commit...");
+		yield* Console.log("Creating commit...");
 		yield* git.commits.write(commitMessage);
-		yield* Console.log("✅ Commit created.");
-		yield* Console.log(`⬆️  Pushing to "${config.branch.release}"...`);
+		yield* Console.log("Commit created.");
+		yield* Console.log(`Pushing to "${config.branch.release}"...`);
 		if (isNewRelease && !branchExists) yield* git.commits.push(config.branch.release);
 		else yield* git.commits.forcePush(config.branch.release);
-		yield* Console.log(`✅ Push complete.`);
+		yield* Console.log(`Push complete.`);
 		const prBody = yield* github.generateReleasePRBody(releases.map((r) => ({
 			packageName: r.package.name,
 			version: r.newVersion,
 			previousVersion: r.package.version
 		})));
 		if (isNewRelease) {
-			yield* Console.log("📋 Creating release pull request...");
+			yield* Console.log("Creating release pull request...");
 			releasePullRequest = yield* github.createPullRequest({
 				title: config.pullRequest.title,
 				body: prBody,
@@ -1276,13 +1602,15 @@ ${releases.map((r) => `  - ${r.package.name}@${r.newVersion}`).join("\n")}`;
 				base: config.branch.default,
 				draft: true
 			});
-			yield* Console.log(`✅ Release pull request #${releasePullRequest.number} created.`);
+			yield* Console.log(`Release pull request #${releasePullRequest.number} created.`);
 		} else {
-			yield* Console.log("📄 Updating pull request...");
+			yield* Console.log("Updating pull request...");
 			yield* github.updatePullRequest(releasePullRequest.number, { body: prBody });
-			yield* Console.log("✅ Pull request updated.");
+			yield* Console.log("Pull request updated.");
 		}
-		yield* Console.log(`\n🎉 Release preparation complete! View PR: #${releasePullRequest.number}`);
+		yield* Console.log(`\nRelease preparation complete! View PR: #${releasePullRequest.number}`);
+		yield* git.branches.checkout(config.branch.default);
+		yield* Console.log(`Switched back to "${config.branch.default}".`);
 	});
 }
 
@@ -1311,9 +1639,9 @@ function constructPublishProgram(config) {
 		yield* git.workspace.assertWorkspaceReady;
 		const currentBranch = yield* git.branches.get;
 		if (currentBranch !== config.branch.default) return yield* Effect.fail(/* @__PURE__ */ new Error(`Publish must be run on the default branch "${config.branch.default}". Current branch: "${currentBranch}"`));
-		yield* Console.log(`✅ On default branch "${config.branch.default}".`);
+		yield* Console.log(`On default branch "${config.branch.default}".`);
 		const publicPackages = (yield* workspace.discoverWorkspacePackages).filter((pkg) => !pkg.packageJson.private);
-		yield* Console.log(`📦 Found ${publicPackages.length} public package${publicPackages.length === 1 ? "" : "s"} to check.`);
+		yield* Console.log(`Found ${publicPackages.length} public package${publicPackages.length === 1 ? "" : "s"} to check.`);
 		const orderedPackages = yield* dependencyGraph.topologicalOrder(publicPackages);
 		const results = [];
 		for (const updateOrder of orderedPackages) {
@@ -1321,7 +1649,7 @@ function constructPublishProgram(config) {
 			const version = pkg.version;
 			const tagName = `${pkg.name}@${version}`;
 			if (yield* npm.versionExists(pkg.name, version)) {
-				yield* Console.log(`⏭️  Skipping ${pkg.name}@${version} - already published.`);
+				yield* Console.log(`Skipping ${pkg.name}@${version} - already published.`);
 				results.push({
 					packageName: pkg.name,
 					version,
@@ -1330,11 +1658,11 @@ function constructPublishProgram(config) {
 				});
 				continue;
 			}
-			yield* Console.log(`🔨 Building ${pkg.name}...`);
+			yield* Console.log(`Building ${pkg.name}...`);
 			yield* buildPackage(pkg.path);
-			yield* Console.log(`✅ Build complete for ${pkg.name}.`);
+			yield* Console.log(`Build complete for ${pkg.name}.`);
 			const distTag = getDistTag(version);
-			yield* Console.log(`🚀 Publishing ${pkg.name}@${version} with tag "${distTag}"...`);
+			yield* Console.log(`Publishing ${pkg.name}@${version} with tag "${distTag}"...`);
 			const publishResult = yield* npm.publish({
 				packagePath: pkg.path,
 				tagName: distTag,
@@ -1346,13 +1674,13 @@ function constructPublishProgram(config) {
 				error: err
 			})));
 			if (publishResult.success) {
-				yield* Console.log(`✅ Published ${pkg.name}@${version}.`);
+				yield* Console.log(`Published ${pkg.name}@${version}.`);
 				if (!config.dryRun) {
-					yield* Console.log(`🏷️  Creating tag ${tagName}...`);
+					yield* Console.log(`Creating tag ${tagName}...`);
 					yield* git.tags.create(tagName, `Release ${tagName}`);
 					yield* git.tags.push(tagName);
-					yield* Console.log(`✅ Tag ${tagName} created and pushed.`);
-				} else yield* Console.log(`🏷️  [Dry Run] Would create and push tag ${tagName}.`);
+					yield* Console.log(`Tag ${tagName} created and pushed.`);
+				} else yield* Console.log(`[Dry Run] Would create and push tag ${tagName}.`);
 				results.push({
 					packageName: pkg.name,
 					version,
@@ -1360,7 +1688,7 @@ function constructPublishProgram(config) {
 				});
 			} else {
 				const error = publishResult.error;
-				yield* Console.log(`❌ Failed to publish ${pkg.name}@${version}: ${error.message}`);
+				yield* Console.log(`Failed to publish ${pkg.name}@${version}: ${error.message}`);
 				results.push({
 					packageName: pkg.name,
 					version,
@@ -1372,17 +1700,17 @@ function constructPublishProgram(config) {
 		const published = results.filter((r) => r.status === "published");
 		const skipped = results.filter((r) => r.status === "skipped");
 		const failed = results.filter((r) => r.status === "failed");
-		yield* Console.log("\n📊 Publish Summary:");
+		yield* Console.log("\nPublish Summary:");
 		yield* Console.log(`   Published: ${published.length}`);
 		yield* Console.log(`   Skipped: ${skipped.length}`);
 		yield* Console.log(`   Failed: ${failed.length}`);
 		if (failed.length > 0) {
-			yield* Console.log("\n❌ Failed packages:");
+			yield* Console.log("\nFailed packages:");
 			for (const f of failed) yield* Console.log(`   - ${f.packageName}@${f.version}: ${f.reason}`);
 			return yield* Effect.fail(/* @__PURE__ */ new Error("Some packages failed to publish."));
 		}
-		if (published.length === 0 && skipped.length > 0) yield* Console.log("\n✅ All packages were already published.");
-		else if (published.length > 0) yield* Console.log("\n🎉 Publish complete!");
+		if (published.length === 0 && skipped.length > 0) yield* Console.log("\nAll packages were already published.");
+		else if (published.length > 0) yield* Console.log("\nPublish complete!");
 	});
 }
 
@@ -1468,10 +1796,10 @@ function constructVerifyProgram(config) {
 		yield* git.workspace.assertWorkspaceReady;
 		const releasePullRequest = yield* github.getPullRequestByBranch(config.branch.release);
 		if (!releasePullRequest || !releasePullRequest.head) return yield* Effect.fail(/* @__PURE__ */ new Error(`Release pull request for branch "${config.branch.release}" does not exist.`));
-		yield* Console.log(`✅ Release pull request #${releasePullRequest.number} exists.`);
+		yield* Console.log(`Release pull request #${releasePullRequest.number} exists.`);
 		if ((yield* git.branches.get) !== config.branch.default) {
 			yield* git.branches.checkout(config.branch.default);
-			yield* Console.log(`✅ Checked out to default branch "${config.branch.default}".`);
+			yield* Console.log(`Checked out to default branch "${config.branch.default}".`);
 		}
 		const overrides = yield* loadOverrides({
 			sha: releasePullRequest.head.sha,
@@ -1491,8 +1819,8 @@ function constructVerifyProgram(config) {
 			branchSnapshots.set(pkg.name, snapshot);
 		}
 		const drift = findDrift(packages, releases, branchSnapshots);
-		if (drift.length === 0) yield* Console.log("✅ Release branch is in sync with expected releases.");
-		else yield* Console.log("❌ Release branch is out of sync:", drift);
+		if (drift.length === 0) yield* Console.log("Release branch is in sync with expected releases.");
+		else yield* Console.log("Release branch is out of sync:", drift);
 		const status = drift.length === 0 ? {
 			state: "success",
 			description: "Release artifacts in sync",
@@ -1511,7 +1839,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.33",
   "description": "@ucdjs release scripts",
   "type": "module",
   "license": "MIT",