fireflyy 4.0.0-dev.25c80f6 → 4.0.0-dev.3098d1f

package/dist/{result.constructors-C9M1MP3_.js → result.constructors-D9jmQ0uj.js}

@@ -253,9 +253,13 @@ const failedErrAsync = (opts) => errAsync(failedError(opts));
 */
 const invalidErr = (opts) => err(invalidError(opts));
 /**
+* Creates an async invalid error result.
+*/
+const invalidErrAsync = (opts) => errAsync(invalidError(opts));
+/**
 * Creates an async timeout error result.
 */
 const timeoutErrAsync = (opts) => errAsync(timeoutError(opts));
 
 //#endregion
-export { validationError as _, conflictErrAsync as a, notFoundErrAsync as c, validationErrAsync as d, conflictError as f, toFireflyError as g, notFoundError as h, FireflyOkAsync as i, timeoutErrAsync as l, failedError as m, FireflyErrAsync as n, failedErrAsync as o, createFireflyError as p, FireflyOk as r, invalidErr as s, FireflyErr as t, validationErr as u, wrapErrorMessage as v };
+export { notFoundError as _, conflictErrAsync as a, wrapErrorMessage as b, invalidErrAsync as c, validationErr as d, validationErrAsync as f, invalidError as g, failedError as h, FireflyOkAsync as i, notFoundErrAsync as l, createFireflyError as m, FireflyErrAsync as n, failedErrAsync as o, conflictError as p, FireflyOk as r, invalidErr as s, FireflyErr as t, timeoutErrAsync as u, toFireflyError as v, validationError as y };

package/dist/{result.utilities-DC5shlhT.js → result.utilities-DiG1ae54.js}

@@ -1,4 +1,4 @@
-import { d as validationErrAsync, g as toFireflyError, i as FireflyOkAsync, p as createFireflyError } from "./result.constructors-C9M1MP3_.js";
+import { f as validationErrAsync, i as FireflyOkAsync, m as createFireflyError, v as toFireflyError } from "./result.constructors-D9jmQ0uj.js";
 import { ResultAsync } from "neverthrow";
 
 //#region src/core/result/result.utilities.ts
@@ -17,16 +17,6 @@ function wrapPromise(promise) {
 function ensureNotAsync(condition, errorOpts) {
 	return condition ? validationErrAsync(errorOpts) : FireflyOkAsync(void 0);
 }
-/**
-* Async version of zip3.
-*/
-function zip3Async(resultA, resultB, resultC) {
-	return ResultAsync.combine([
-		resultA,
-		resultB,
-		resultC
-	]);
-}
 
 //#endregion
-export { wrapPromise as n, zip3Async as r, ensureNotAsync as t };
+export { wrapPromise as n, ensureNotAsync as t };

package/dist/{schema.utilities-BGd9t1wm.js → schema.utilities-Y2MdlRMu.js}

@@ -1,4 +1,4 @@
-import { g as toFireflyError, p as createFireflyError, r as FireflyOk, t as FireflyErr } from "./result.constructors-C9M1MP3_.js";
+import { m as createFireflyError, r as FireflyOk, t as FireflyErr, v as toFireflyError } from "./result.constructors-D9jmQ0uj.js";
 import { ResultAsync } from "neverthrow";
 import z$1 from "zod";
 

package/dist/version-D6rAEmbf.js

@@ -0,0 +1,164 @@
+import { r as FireflyOk, s as invalidErr } from "./result.constructors-D9jmQ0uj.js";
+import semver from "semver";
+
+//#region src/domain/semver/version.ts
+/**
+* Represents a parsed semantic version with immutable access.
+*
+* @example
+* ```ts
+* const result = Version.from("1.2.3-alpha.1");
+* if (result.isOk()) {
+*   console.log(result.value.major); // 1
+*   console.log(result.value.isPrerelease); // true
+* }
+* ```
+*/
+var Version = class Version {
+	_raw;
+	_parsed;
+	constructor(version, parsed) {
+		this._raw = version;
+		this._parsed = parsed;
+	}
+	/**
+	* Creates a Version from any valid semver string.
+	* Handles cleaning (removing 'v' prefix, etc.).
+	*/
+	static from(input) {
+		const cleaned = semver.clean(input);
+		if (!cleaned) return invalidErr({ message: `"${input}" is not a valid semantic version.` });
+		const parsed = semver.parse(cleaned);
+		if (!parsed) return invalidErr({ message: `Failed to parse semantic version "${cleaned}".` });
+		return FireflyOk(new Version(cleaned, parsed));
+	}
+	/**
+	* Creates a Version from an already-clean semver string.
+	* Use when you know the input is already normalized.
+	*/
+	static fromClean(cleanVersion) {
+		const parsed = semver.parse(cleanVersion);
+		if (!parsed) return invalidErr({ message: `Expected clean version but got invalid: ${cleanVersion}` });
+		return FireflyOk(new Version(cleanVersion, parsed));
+	}
+	/**
+	* The raw version string.
+	*/
+	get raw() {
+		return this._raw;
+	}
+	/**
+	* Major version number.
+	*/
+	get major() {
+		return this._parsed.major;
+	}
+	/**
+	* Minor version number.
+	*/
+	get minor() {
+		return this._parsed.minor;
+	}
+	/**
+	* Patch version number.
+	*/
+	get patch() {
+		return this._parsed.patch;
+	}
+	/**
+	* Whether this version has prerelease identifiers.
+	*/
+	get isPrerelease() {
+		return this._parsed.prerelease.length > 0;
+	}
+	/**
+	* Prerelease identifiers (e.g., ["alpha", 1] for "1.0.0-alpha.1").
+	*/
+	get prerelease() {
+		return this._parsed.prerelease;
+	}
+	/**
+	* The prerelease identifier (e.g., "alpha" from "1.0.0-alpha.1").
+	*/
+	get preReleaseID() {
+		if (!this.isPrerelease) return null;
+		const first = this._parsed.prerelease[0];
+		return typeof first === "string" ? first : null;
+	}
+	/**
+	* The prerelease number (e.g., 1 from "1.0.0-alpha.1").
+	*/
+	get prereleaseNumber() {
+		if (!this.isPrerelease) return null;
+		const last = this._parsed.prerelease.at(-1);
+		return typeof last === "number" ? last : null;
+	}
+	/**
+	* Build metadata identifiers.
+	*/
+	get build() {
+		return this._parsed.build;
+	}
+	/**
+	* Returns the raw version string.
+	*/
+	toString() {
+		return this._raw;
+	}
+	/**
+	* Checks equality with another Version.
+	*
+	* @param other - The other Version to compare with
+	* @returns True if equal, false otherwise
+	*/
+	equals(other) {
+		return semver.eq(this._raw, other._raw);
+	}
+	/**
+	* Compares with another Version: -1 (less), 0 (equal), 1 (greater).
+	*
+	* @param other - The other Version to compare with
+	* @returns -1, 0, or 1 based on comparison
+	*/
+	compare(other) {
+		return semver.compare(this._raw, other._raw);
+	}
+	/**
+	* Checks if this version is greater than another.
+	*
+	* @param other - The other Version to compare with
+	* @returns True if this version is greater, false otherwise
+	*/
+	isGreaterThan(other) {
+		return semver.gt(this._raw, other._raw);
+	}
+	/**
+	* Checks if this version is less than another.
+	*
+	* @param other - The other Version to compare with
+	* @returns True if this version is less, false otherwise
+	*/
+	isLessThan(other) {
+		return semver.lt(this._raw, other._raw);
+	}
+	/**
+	* Checks if this version satisfies a semver range.
+	*
+	* @param range - The semver range to check against
+	* @returns True if it satisfies the range, false otherwise
+	*/
+	satisfies(range) {
+		return semver.satisfies(this._raw, range);
+	}
+	/**
+	* Converts a prerelease version to its stable form.
+	* "1.2.3-alpha.1" → "1.2.3"
+	*/
+	toStable() {
+		const stableVersion = `${this.major}.${this.minor}.${this.patch}`;
+		return Version.fromClean(stableVersion);
+	}
+};
+
+//#endregion
+export { Version as t };

package/dist/version-bumper.service-ZBJ2jcLS.js

@@ -0,0 +1,171 @@
+import { c as invalidErrAsync, i as FireflyOkAsync, n as FireflyErrAsync, r as FireflyOk, s as invalidErr, t as FireflyErr } from "./result.constructors-D9jmQ0uj.js";
+import { t as Version } from "./version-D6rAEmbf.js";
+import semver from "semver";
+
+//#region src/services/implementations/version-bumper.service.ts
+/**
+* Default implementation of the version bumper service.
+*/
+var DefaultVersionBumperService = class {
+	bump(options) {
+		const { currentVersion, releaseType, preReleaseID, preReleaseBase } = options;
+		if (releaseType === "major" || releaseType === "minor" || releaseType === "patch") {
+			const result = this.bumpStandard(currentVersion, releaseType);
+			return result.isOk() ? FireflyOkAsync(result.value) : FireflyErrAsync(result.error);
+		}
+		if (releaseType === "premajor" || releaseType === "preminor" || releaseType === "prepatch") {
+			const result = this.bumpPreStandard(currentVersion, releaseType, preReleaseID, preReleaseBase);
+			return result.isOk() ? FireflyOkAsync(result.value) : FireflyErrAsync(result.error);
+		}
+		if (releaseType === "prerelease") {
+			const result = this.bumpPrerelease(currentVersion, preReleaseID, preReleaseBase);
+			return result.isOk() ? FireflyOkAsync(result.value) : FireflyErrAsync(result.error);
+		}
+		if (releaseType === "graduate") {
+			const result = this.graduatePrerelease(currentVersion);
+			return result.isOk() ? FireflyOkAsync(result.value) : FireflyErrAsync(result.error);
+		}
+		return invalidErrAsync({
+			message: `Unsupported release type: ${releaseType}`,
+			source: "services/version-bumper"
+		});
+	}
+	/**
+	* Normalizes the prerelease base to a string "0" or "1".
+	*
+	* @param base - The prerelease base to normalize
+	* @returns The normalized base or an error if invalid
+	*/
+	normalizeBase(base) {
+		if (base === void 0 || base === null) return FireflyOk(void 0);
+		if (base === "0" || base === "1") return FireflyOk(base);
+		if (typeof base === "number" && (base === 0 || base === 1)) return FireflyOk(base.toString());
+		return invalidErr({ message: `Invalid preReleaseBase '${base}'. Must be "0", "1", 0, or 1.` });
+	}
+	/**
+	* Determines if the prerelease identifier is complex (contains dots).
+	*
+	* @param identifier - The prerelease identifier to check
+	* @returns True if the identifier is complex, false otherwise
+	*/
+	isComplexIdentifier(identifier) {
+		return typeof identifier === "string" && identifier.includes(".");
+	}
+	/**
+	* Bumps a version with a complex prerelease identifier (e.g., "canary.abc123").
+	*
+	* @param currentVersion - The current version to bump
+	* @param identifier - The complex prerelease identifier
+	* @returns The new version with the complex identifier
+	*/
+	bumpWithComplexIdentifier(currentVersion, identifier) {
+		if (!identifier) return semver.inc(currentVersion.raw, "prerelease", void 0, "0");
+		return semver.inc(currentVersion.raw, "prerelease", identifier, false);
+	}
+	/**
+	* Bumps an existing prerelease version.
+	*
+	* @param currentVersion - The current version to bump
+	* @param identifier - Optional prerelease identifier
+	* @returns The new prerelease version
+	*/
+	bumpExistingPrerelease(currentVersion, identifier) {
+		return identifier ? semver.inc(currentVersion.raw, "prerelease", identifier) : semver.inc(currentVersion.raw, "prerelease");
+	}
+	/**
+	* Bumps a standard version (major, minor, patch) according to the provided release type.
+	*
+	* @param currentVersion - The current version to bump
+	* @param releaseType - The type of standard release
+	* @returns The new standard version
+	*/
+	bumpStandard(currentVersion, releaseType) {
+		let baseVersionString = currentVersion.raw;
+		if (currentVersion.isPrerelease) {
+			const stableResult = currentVersion.toStable();
+			if (stableResult.isErr()) return FireflyErr(stableResult.error);
+			baseVersionString = stableResult.value.raw;
+		}
+		const newVersionString = semver.inc(baseVersionString, releaseType);
+		if (!newVersionString) return invalidErr({
+			message: `Failed to bump ${releaseType} version from '${baseVersionString}'.`,
+			source: "services/version-bumper"
+		});
+		return Version.fromClean(newVersionString);
+	}
+	/**
+	* Bumps a pre-standard version (premajor, preminor, prepatch) according to the provided options.
+	*
+	* @param currentVersion - The current version to bump
+	* @param releaseType - The type of pre-standard release
+	* @param identifier - Optional prerelease identifier (e.g., "alpha", "beta")
+	* @param base - Optional base number for the prerelease
+	* @returns The new pre-standard version
+	*/
+	bumpPreStandard(currentVersion, releaseType, preReleaseID, preReleaseBase) {
+		const normalizedBaseResult = this.normalizeBase(preReleaseBase);
+		if (normalizedBaseResult.isErr()) return FireflyErr(normalizedBaseResult.error);
+		const normalizedBase = normalizedBaseResult.value;
+		let newVersionString = null;
+		if (normalizedBase !== void 0) newVersionString = preReleaseID ? semver.inc(currentVersion.raw, releaseType, preReleaseID, normalizedBase) : semver.inc(currentVersion.raw, releaseType, void 0, normalizedBase);
+		else newVersionString = preReleaseID ? semver.inc(currentVersion.raw, releaseType, preReleaseID) : semver.inc(currentVersion.raw, releaseType);
+		if (!newVersionString) return invalidErr({
+			message: `Failed to bump ${releaseType} version from '${currentVersion.raw}' with identifier '${preReleaseID}' and base '${preReleaseBase}'.`,
+			source: "services/version-bumper"
+		});
+		return Version.fromClean(newVersionString);
+	}
+	/**
+	* Bumps a prerelease version according to the provided options.
+	* Handles complex identifiers, explicit bases, continuing existing
+	* prereleases, and starting new prereleases from stable versions.
+	*
+	* @param currentVersion - The current version to bump
+	* @param identifier - Optional prerelease identifier (e.g., "alpha", "beta")
+	* @param base - Optional base number for the prerelease
+	* @returns The new prerelease version
+	*/
+	bumpPrerelease(currentVersion, preReleaseID, preReleaseBase) {
+		let newVersionString = null;
+		if (this.isComplexIdentifier(preReleaseID)) newVersionString = this.bumpWithComplexIdentifier(currentVersion, preReleaseID);
+		else if (preReleaseBase !== void 0 && preReleaseBase !== null) {
+			const normalizedBaseResult = this.normalizeBase(preReleaseBase);
+			if (normalizedBaseResult.isErr()) return FireflyErr(normalizedBaseResult.error);
+			const normalizedBase = normalizedBaseResult.value;
+			newVersionString = preReleaseID ? semver.inc(currentVersion.raw, "prerelease", preReleaseID, normalizedBase) : semver.inc(currentVersion.raw, "prerelease", void 0, normalizedBase);
+		} else if (currentVersion.isPrerelease) newVersionString = this.bumpExistingPrerelease(currentVersion, preReleaseID);
+		else {
+			const defaultIdentifier = preReleaseID || "alpha";
+			newVersionString = semver.inc(currentVersion.raw, "prerelease", defaultIdentifier);
+		}
+		if (!newVersionString) return invalidErr({
+			message: `Failed to bump prerelease version from '${currentVersion.raw}' with identifier '${preReleaseID}' and base '${preReleaseBase}'.`,
+			source: "services/version-bumper"
+		});
+		return Version.fromClean(newVersionString);
+	}
+	/**
+	* Graduates a prerelease version to its stable counterpart.
+	*
+	* @param currentVersion - The current prerelease version
+	* @returns The stable version
+	*/
+	graduatePrerelease(currentVersion) {
+		if (!currentVersion.isPrerelease) return invalidErr({
+			message: `Cannot graduate non-prerelease version '${currentVersion.raw}'. Only prerelease versions can be graduated.`,
+			source: "services/version-bumper"
+		});
+		const stableVersionResult = currentVersion.toStable();
+		if (stableVersionResult.isErr()) return FireflyErr(stableVersionResult.error);
+		return FireflyOk(stableVersionResult.value);
+	}
+};
+/**
+* Creates a version bumper service instance.
+*/
+function createVersionBumperService() {
+	return new DefaultVersionBumperService();
+}
+
+//#endregion
+export { createVersionBumperService };

package/dist/version-strategy.service-BdpKRWLc.js

@@ -0,0 +1,257 @@
+import { g as invalidError, i as FireflyOkAsync, n as FireflyErrAsync } from "./result.constructors-D9jmQ0uj.js";
+import { t as logger } from "./logging-BuIkRrn1.js";
+import { ResultAsync } from "neverthrow";
+
+//#region src/services/implementations/version-strategy.service.ts
+const TRANSITION_KEYWORDS = [
+	"general availability",
+	"promote to stable",
+	"move to stable"
+];
+const LEVEL_TO_RELEASE_TYPE = {
+	0: "major",
+	1: "minor",
+	2: "patch"
+};
+/**
+* Version type categories for organizing choices.
+*/
+const VERSION_TYPES = {
+	RELEASE: [
+		"patch",
+		"minor",
+		"major"
+	],
+	PRERELEASE: [
+		"prepatch",
+		"preminor",
+		"premajor"
+	],
+	CONTINUATION: ["prerelease"],
+	GRADUATION: ["graduate"]
+};
+/**
+* Pre-configured choice sets for different scenarios.
+*/
+const VERSION_CHOICE_SETS = {
+	latestIsPreRelease: [
+		...VERSION_TYPES.CONTINUATION,
+		...VERSION_TYPES.GRADUATION,
+		...VERSION_TYPES.RELEASE
+	],
+	preRelease: VERSION_TYPES.PRERELEASE,
+	default: [...VERSION_TYPES.RELEASE, ...VERSION_TYPES.PRERELEASE]
+};
+/**
+* Human-readable descriptions for each release type.
+*/
+const VERSION_DESCRIPTIONS = {
+	patch: "Fixes and minor enhancements without breaking compatibility. Suitable for bug fixes and small improvements.",
+	minor: "New, backward-compatible functionality. Adds features that do not break existing APIs.",
+	major: "Incompatible API changes. Introduces breaking changes or removes deprecated features.",
+	prepatch: "Unstable patch release candidate. Used for testing patch changes before a stable release.",
+	preminor: "Unstable minor release candidate. Used for previewing new features before a minor release.",
+	premajor: "Unstable major release candidate. Used for testing breaking changes before a major release.",
+	prerelease: "Unstable pre-release continuation. Increments the pre-release number or changes identifier.",
+	graduate: "Promote pre-release to stable. Removes pre-release identifiers to create a stable version."
+};
+/**
+* Default implementation of the version strategy service.
+*/
+var DefaultVersionStrategyService = class {
+	bumper;
+	constructor(bumper) {
+		this.bumper = bumper;
+	}
+	resolveVersion(options, recommendation) {
+		logger.verbose("DefaultVersionStrategyService: Deciding next version...");
+		const preReleaseContext = this.analyzePreReleaseContext(options.currentVersion, recommendation);
+		if (options.releaseType === "prerelease") {
+			logger.verbose("DefaultVersionStrategyService: Handling prerelease request...");
+			return this.handlePreReleaseRequest(options, preReleaseContext);
+		}
+		if (preReleaseContext.isCurrentPreRelease && preReleaseContext.hasStableTransition) {
+			logger.verbose("DefaultVersionStrategyService: Handling pre-release to stable transition...");
+			return this.handlePreReleaseToStableTransition(options, recommendation);
+		}
+		if (recommendation) {
+			logger.verbose("DefaultVersionStrategyService: Handling recommendation-based versioning...");
+			return this.createRecommendationBasedVersion(options, recommendation, preReleaseContext);
+		}
+		if (options.releaseType) {
+			logger.verbose("DefaultVersionStrategyService: Handling explicit release type...");
+			return this.bumper.bump({
+				currentVersion: options.currentVersion,
+				releaseType: options.releaseType,
+				preReleaseID: options.preReleaseID,
+				preReleaseBase: options.preReleaseBase
+			});
+		}
+		return FireflyErrAsync(invalidError({ message: "Cannot determine next version: no release type or recommendation provided" }));
+	}
+	generateChoices(options) {
+		logger.verbose(`DefaultVersionStrategyService: Creating version choices for '${options.currentVersion.raw}'...`);
+		const choicesResults = this.determineAvailableVersionTypes(options.currentVersion, options.releaseType).map((releaseType) => this.createSingleChoice(options.currentVersion, releaseType, options.preReleaseID, options.preReleaseBase));
+		return ResultAsync.combine(choicesResults).map((choices) => {
+			logger.verbose(`DefaultVersionStrategyService: Created ${choices.length} version choices.`);
+			return choices;
+		});
+	}
+	/**
+	* Analyzes the current version and recommendation to determine pre-release context.
+	*
+	* @param currentVersion - The current version
+	* @param recommendation - The version recommendation
+	* @returns The pre-release context
+	*/
+	analyzePreReleaseContext(currentVersion, recommendation) {
+		return {
+			isCurrentPreRelease: currentVersion.isPrerelease,
+			preReleaseID: currentVersion.preReleaseID,
+			hasStableTransition: this.detectStableTransition(recommendation)
+		};
+	}
+	/**
+	* Detects if the recommendation indicates a transition to a stable version.
+	*
+	* @param recommendation - The version recommendation
+	* @returns True if a stable transition is detected, false otherwise
+	*/
+	detectStableTransition(recommendation) {
+		if (!recommendation) return false;
+		const reason = recommendation.reason.toLowerCase();
+		return TRANSITION_KEYWORDS.some((keyword) => reason.includes(keyword));
+	}
+	/**
+	* Handles explicit requests for pre-release versions.
+	*
+	* @param options - The version resolution options
+	* @param context - The pre-release context
+	* @returns A result containing the new pre-release version or an error
+	*/
+	handlePreReleaseRequest(options, context) {
+		logger.verbose("DefaultVersionStrategyService: Bumping to prerelease version...");
+		return this.bumper.bump({
+			currentVersion: options.currentVersion,
+			releaseType: "prerelease",
+			preReleaseID: options.preReleaseID ?? context.preReleaseID ?? "alpha",
+			preReleaseBase: options.preReleaseBase
+		});
+	}
+	/**
+	* Handles the transition from a pre-release version to a stable version.
+	*
+	* @param options - The version resolution options
+	* @param recommendation - The version recommendation
+	* @returns A result containing the new stable version or an error
+	*/
+	handlePreReleaseToStableTransition(options, recommendation) {
+		if (!recommendation) return FireflyErrAsync(invalidError({
+			message: "Cannot transition to stable version without recommendation",
+			source: "services/version-strategy"
+		}));
+		return this.bumper.bump({
+			currentVersion: options.currentVersion,
+			releaseType: "graduate"
+		}).andThen((stableVersion) => {
+			if (recommendation.level < 2) {
+				logger.verbose("DefaultVersionStrategyService: Further bumping after graduation...");
+				const releaseType = LEVEL_TO_RELEASE_TYPE[recommendation.level];
+				return this.bumper.bump({
+					currentVersion: stableVersion,
+					releaseType
+				});
+			}
+			logger.verbose("DefaultVersionStrategyService: Graduated to stable version:", stableVersion.raw);
+			return FireflyOkAsync(stableVersion);
+		});
+	}
+	/**
+	* Creates a new version based on the provided recommendation and pre-release context.
+	*
+	* @param options - The version resolution options
+	* @param recommendation - The version recommendation
+	* @param context - The pre-release context
+	* @returns A result containing the new version or an error
+	*/
+	createRecommendationBasedVersion(options, recommendation, context) {
+		if (context.isCurrentPreRelease && !context.hasStableTransition) {
+			logger.verbose("DefaultVersionStrategyService: Continuing prerelease versioning...");
+			return this.bumper.bump({
+				currentVersion: options.currentVersion,
+				releaseType: "prerelease",
+				preReleaseID: options.preReleaseID ?? context.preReleaseID ?? "alpha",
+				preReleaseBase: options.preReleaseBase
+			});
+		}
+		const releaseType = LEVEL_TO_RELEASE_TYPE[recommendation.level];
+		logger.verbose("DefaultVersionStrategyService: Bumping version based on recommendation...");
+		return this.bumper.bump({
+			currentVersion: options.currentVersion,
+			releaseType,
+			preReleaseID: options.preReleaseID,
+			preReleaseBase: options.preReleaseBase
+		});
+	}
+	/**
+	* Determines the available version types based on current version and optional release type.
+	*
+	* @param currentVersion - The current version
+	* @param releaseType - Optional specific release type
+	* @returns An array of available release types
+	*/
+	determineAvailableVersionTypes(currentVersion, releaseType) {
+		if (releaseType !== void 0) return this.getVersionTypesForReleaseType(releaseType);
+		return currentVersion.isPrerelease ? VERSION_CHOICE_SETS.latestIsPreRelease : VERSION_CHOICE_SETS.default;
+	}
+	/**
+	* Retrieves the version types applicable for a given release type.
+	*
+	* @param releaseType - The type of release
+	* @returns An array of applicable release types
+	*/
+	getVersionTypesForReleaseType(releaseType) {
+		return releaseType === "prerelease" ? VERSION_CHOICE_SETS.preRelease : VERSION_CHOICE_SETS.default;
+	}
+	/**
+	* Retrieves the description for a given release type.
+	*
+	* @param releaseType - The type of release
+	* @returns The description string for the release type
+	*/
+	getVersionDescription(releaseType) {
+		return VERSION_DESCRIPTIONS[releaseType] ?? "";
+	}
+	/**
+	* Creates a single version choice based on the provided parameters.
+	*
+	* @param currentVersion - The current version
+	* @param releaseType - The type of release to create
+	* @param preReleaseID - Optional pre-release identifier
+	* @param preReleaseBase - Optional base for pre-release
+	* @returns A result containing the version choice or an error
+	*/
+	createSingleChoice(currentVersion, releaseType, preReleaseID, preReleaseBase) {
+		const bumpOptions = {
+			currentVersion,
+			releaseType,
+			preReleaseID,
+			preReleaseBase
+		};
+		return this.bumper.bump(bumpOptions).map((newVersion) => ({
+			label: `${releaseType} (${newVersion.raw})`,
+			hint: this.getVersionDescription(releaseType),
+			value: newVersion.raw
+		}));
+	}
+};
+/**
+* Creates a version strategy service instance.
+* @param bumper - The version bumper service to use
+*/
+function createVersionStrategyService(bumper) {
+	return new DefaultVersionStrategyService(bumper);
+}
+
+//#endregion
+export { TRANSITION_KEYWORDS, createVersionStrategyService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fireflyy",
-  "version": "4.0.0-dev.25c80f6",
+  "version": "4.0.0-dev.3098d1f",
   "description": " CLI orchestrator for automatic semantic versioning, changelog generation, and creating releases. Built for my own use cases.",
   "type": "module",
   "license": "MIT",
@@ -65,9 +65,9 @@
     "@biomejs/biome": "2.3.8",
     "@types/bun": "^1.3.3",
     "@types/semver": "^7.7.1",
-    "tsdown": "^0.17.0-beta.5",
+    "tsdown": "^0.17.0",
     "typescript": "^5.9.3",
-    "ultracite": "6.3.8"
+    "ultracite": "6.3.9"
   },
   "keywords": [
     "cli",