fireflyy 4.0.0-dev.c94480d → 4.0.0-dev.df58d2b

package/dist/commit-analysis.service-CtIh7eez.js

@@ -0,0 +1,503 @@
+import { t as logger } from "./main.js";
+import { g as invalidError, i as FireflyOkAsync, r as FireflyOk, t as FireflyErr } from "./result.constructors-D9jmQ0uj.js";
+import { n as TRANSITION_KEYWORDS } from "./version-strategy.service-vh5KeNCA.js";
+
+//#region src/domain/commits/commit-types.ts
+/**
+* Default configuration for conventional commit type analysis.
+*/
+const DEFAULT_COMMIT_TYPE_CONFIG = {
+	major: ["revert"],
+	minor: ["feat", "feature"],
+	patch: [
+		"fix",
+		"perf",
+		"refactor",
+		"style",
+		"test",
+		"build",
+		"ci",
+		"chore",
+		"docs",
+		"security"
+	],
+	scopeRules: {
+		deps: "patch",
+		dependencies: "patch",
+		security: "patch",
+		api: "minor",
+		breaking: "major",
+		"breaking-change": "major"
+	}
+};
+
+//#endregion
+//#region src/services/implementations/commit-analysis.service.ts
+const COMMIT_MESSAGE_PATTERNS = {
+	BREAKING: /^(\w*)(?:\((.*)\))?!: (.*)$/,
+	CONVENTIONAL: /^(\w*)(?:\((.*)\))?: (.*)$/,
+	REVERT: /^Revert "(.+)"\s*\[([a-f0-9]+)\]$/
+};
+const EXTRACTION_PATTERNS = {
+	BREAKING_CHANGE: /BREAKING CHANGE:\s*(.+?)(?=\n\n|\n[A-Z]|$)/gs,
+	MENTION: /@([a-zA-Z0-9_-]+)/g,
+	REFERENCE: /(fixes?|closes?|resolves?)\s+#(\d+)|#(\d+)/gi
+};
+const ANALYSIS_PATTERNS = {
+	BREAKING_HEADER: /^[a-zA-Z]+(?:\([^)]*\))?!:/,
+	SCOPE_HEADER: /^[a-zA-Z]+\(([^)]+)\)[:!]/
+};
+const VERSION_LEVELS = {
+	MAJOR: 0,
+	MINOR: 1,
+	PATCH: 2
+};
+const LEVEL_TO_RELEASE_TYPE = {
+	0: "major",
+	1: "minor",
+	2: "patch"
+};
+var DefaultCommitAnalysisService = class {
+	git;
+	constructor(git) {
+		this.git = git;
+	}
+	analyzeForVersion(options) {
+		logger.verbose("CommitAnalysisService: Starting commit analysis for version recommendation...");
+		const startTime = Date.now();
+		return this.getCommitsSinceLastTag().map((commits) => {
+			if (commits.length === 0) {
+				logger.verbose("CommitAnalysisService: No commits provided, returning patch recommendation.");
+				return this.createDefaultPatchRecommendation();
+			}
+			const config = this.mergeConfiguration(options?.config ?? {});
+			const analysis = this.performDetailedAnalysis(commits, config);
+			const versionLevel = this.determineVersionLevel(analysis);
+			const recommendation = this.buildVersionRecommendation(versionLevel, analysis);
+			const duration = Date.now() - startTime;
+			logger.verbose(`CommitAnalysisService: Analysis completed in ${duration}ms. Recommendation: ${recommendation.releaseType}`);
+			return recommendation;
+		});
+	}
+	createDefaultRecommendation() {
+		return this.createDefaultPatchRecommendation();
+	}
+	/**
+	* Retrieves commits since the last tag without analysis.
+	*
+	* @returns Array of parsed commits
+	*/
+	getCommitsSinceLastTag() {
+		logger.verbose("CommitAnalysisService: Retrieving commits since last tag");
+		return this.git.getLatestTag().andThen((lastTag) => {
+			logger.verbose(`CommitAnalysisService: Last tag is: ${lastTag ?? "none"}`);
+			return this.git.getCommitHashesSince(lastTag).andThen((hashes) => {
+				if (hashes.length === 0) {
+					logger.verbose("CommitAnalysisService: No new commits found since last tag");
+					return FireflyOkAsync([]);
+				}
+				return this.parseCommitHashes(hashes);
+			});
+		});
+	}
+	/**
+	* Extracts commit fields from raw commit details.
+	*
+	* @param rawDetails - The raw commit details string
+	* @returns An object containing extracted commit fields
+	*/
+	extractCommitFields(rawDetails) {
+		const lines = rawDetails.trim().split("\n");
+		const commitData = {};
+		for (const line of lines) {
+			const colonIndex = line.indexOf(":");
+			if (colonIndex === -1) continue;
+			const key = line.substring(0, colonIndex);
+			commitData[key] = line.substring(colonIndex + 1);
+		}
+		return {
+			subject: commitData.subject ?? "",
+			body: commitData.body ?? "",
+			author: commitData.author ?? "",
+			date: commitData.date ?? "",
+			notes: commitData.notes ?? ""
+		};
+	}
+	/**
+	* Analyzes the commit message to extract type, scope, and subject.
+	*
+	* @param subject - The commit subject line
+	* @returns An object with type, scope, and subject
+	*/
+	analyzeCommitMessage(subject) {
+		const breakingMatch = subject.match(COMMIT_MESSAGE_PATTERNS.BREAKING);
+		if (breakingMatch) return {
+			type: breakingMatch[1] ?? null,
+			scope: breakingMatch[2] ?? null,
+			subject: breakingMatch[3] ?? null
+		};
+		const conventionalMatch = subject.match(COMMIT_MESSAGE_PATTERNS.CONVENTIONAL);
+		if (conventionalMatch) return {
+			type: conventionalMatch[1] ?? null,
+			scope: conventionalMatch[2] ?? null,
+			subject: conventionalMatch[3] ?? null
+		};
+		return {
+			type: null,
+			scope: null,
+			subject: subject || null
+		};
+	}
+	/**
+	* Extracts revert information from commit subject.
+	*
+	* @param subject - The commit subject line
+	* @returns An object with revert header and hash, or null if not a revert
+	*/
+	extractRevertInfo(subject) {
+		const revertMatch = subject.match(COMMIT_MESSAGE_PATTERNS.REVERT);
+		if (revertMatch) return {
+			header: revertMatch[1] ?? null,
+			hash: revertMatch[2] ?? null
+		};
+		return null;
+	}
+	/**
+	* Extracts BREAKING CHANGE notes from commit body and notes.
+	*
+	* @param body - The commit body text
+	* @param notes - The commit notes text
+	* @returns An array of CommitNote objects
+	*/
+	extractBreakingChangeNotes(body, notes) {
+		const breakingNotes = [];
+		const fullText = `${body}\n${notes}`;
+		EXTRACTION_PATTERNS.BREAKING_CHANGE.lastIndex = 0;
+		let match = EXTRACTION_PATTERNS.BREAKING_CHANGE.exec(fullText);
+		while (match !== null) {
+			const text = match[1];
+			if (text) breakingNotes.push({
+				title: "BREAKING CHANGE",
+				text: text.trim()
+			});
+			match = EXTRACTION_PATTERNS.BREAKING_CHANGE.exec(fullText);
+		}
+		return breakingNotes;
+	}
+	/**
+	* Extracts @mentions from commit text.
+	*
+	* @param text - The commit text to analyze
+	* @returns An array of mention strings
+	*/
+	extractMentions(text) {
+		const mentions = [];
+		EXTRACTION_PATTERNS.MENTION.lastIndex = 0;
+		let match = EXTRACTION_PATTERNS.MENTION.exec(text);
+		while (match !== null) {
+			const mention = match[1];
+			if (mention) mentions.push(mention);
+			match = EXTRACTION_PATTERNS.MENTION.exec(text);
+		}
+		return mentions;
+	}
+	/**
+	* Extracts issue/PR references from commit text.
+	*
+	* @param text - The commit text to analyze
+	* @returns An array of CommitReference objects
+	*/
+	extractReferences(text) {
+		const references = [];
+		EXTRACTION_PATTERNS.REFERENCE.lastIndex = 0;
+		let match = EXTRACTION_PATTERNS.REFERENCE.exec(text);
+		while (match !== null) {
+			const action = match[1] ?? null;
+			const issue = match[2] ?? match[3];
+			if (issue) references.push({
+				raw: match[0],
+				action: action?.toLowerCase() ?? null,
+				owner: null,
+				repository: null,
+				issue,
+				prefix: "#"
+			});
+			match = EXTRACTION_PATTERNS.REFERENCE.exec(text);
+		}
+		return references;
+	}
+	/**
+	* Parses raw commit details into a Commit object.
+	*
+	* @param rawDetails - The raw commit details string
+	* @param hash - The commit hash
+	* @returns A FireflyResult containing the parsed Commit object
+	*/
+	parseCommitFromRaw(rawDetails, hash) {
+		if (!rawDetails || typeof rawDetails !== "string") return FireflyErr(invalidError({ message: `Invalid commit details for ${hash}` }));
+		const details = this.extractCommitFields(rawDetails);
+		const messageAnalysis = this.analyzeCommitMessage(details.subject);
+		const revertInfo = this.extractRevertInfo(details.subject);
+		const breakingNotes = this.extractBreakingChangeNotes(details.body, details.notes);
+		const mentions = this.extractMentions(details.body);
+		const references = this.extractReferences(details.body);
+		return FireflyOk({
+			hash,
+			date: details.date || null,
+			author: details.author || null,
+			header: details.subject || null,
+			body: details.body || null,
+			footer: null,
+			type: messageAnalysis.type,
+			scope: messageAnalysis.scope,
+			subject: messageAnalysis.subject,
+			merge: null,
+			revert: revertInfo,
+			notes: breakingNotes,
+			mentions,
+			references
+		});
+	}
+	/**
+	* Parses a list of commit hashes into Commit objects.
+	*
+	* @param hashes - The list of commit hashes to parse
+	* @returns A FireflyAsyncResult containing the list of parsed Commit objects
+	*/
+	parseCommitHashes(hashes) {
+		return hashes.reduce((acc, hash) => acc.andThen((commits) => this.git.getCommitDetails(hash).andThen((rawDetails) => {
+			const parsed = this.parseCommitFromRaw(rawDetails, hash);
+			if (parsed.isErr()) {
+				logger.verbose(`CommitAnalysisService: Failed to parse commit ${hash}: ${parsed.error.message}`);
+				return FireflyOkAsync(commits);
+			}
+			return FireflyOkAsync([...commits, parsed.value]);
+		})), FireflyOkAsync([]));
+	}
+	/**
+	* Merges user-provided commit type configuration with defaults.
+	*
+	* @param partial - Partial commit type configuration from user
+	* @returns Complete commit type configuration
+	*/
+	mergeConfiguration(partial) {
+		return {
+			major: [...DEFAULT_COMMIT_TYPE_CONFIG.major, ...partial.major ?? []],
+			minor: [...DEFAULT_COMMIT_TYPE_CONFIG.minor, ...partial.minor ?? []],
+			patch: [...DEFAULT_COMMIT_TYPE_CONFIG.patch, ...partial.patch ?? []],
+			scopeRules: {
+				...DEFAULT_COMMIT_TYPE_CONFIG.scopeRules,
+				...partial.scopeRules
+			}
+		};
+	}
+	/**
+	* Determines if the commit header indicates a breaking change.
+	*
+	* @param commit - The commit to analyze
+	* @returns True if the header indicates a breaking change, false otherwise
+	*/
+	hasBreakingHeader(commit) {
+		if (!commit.header) return false;
+		return ANALYSIS_PATTERNS.BREAKING_HEADER.test(commit.header);
+	}
+	/**
+	* Counts the number of breaking changes in a commit.
+	*
+	* @param commit - The commit to analyze
+	* @returns The number of breaking changes found
+	*/
+	countBreakingChanges(commit) {
+		let breakingCount = 0;
+		breakingCount += commit.notes?.length ?? 0;
+		if (this.hasBreakingHeader(commit)) breakingCount += 1;
+		return breakingCount;
+	}
+	/**
+	* Determines if the commit is a feature commit.
+	*
+	* @param commit - The commit to analyze
+	* @param config - The commit type configuration
+	* @returns True if the commit is a feature commit, false otherwise
+	*/
+	isFeatureCommit(commit, config) {
+		const type = commit.type?.toLowerCase() ?? "";
+		return config.minor.includes(type);
+	}
+	/**
+	* Determines if the commit is a patch-level commit.
+	*
+	* @param commit - The commit to analyze
+	* @param config - The commit type configuration
+	* @returns True if the commit is a patch-level commit, false otherwise
+	*/
+	isPatchCommit(commit, config) {
+		const type = commit.type?.toLowerCase() ?? "";
+		return config.patch.includes(type);
+	}
+	/**
+	* Extracts the scope from a commit.
+	*
+	* @param commit - The commit to extract the scope from
+	* @returns The extracted scope or null if not found
+	*/
+	extractCommitScope(commit) {
+		if (commit.scope) return commit.scope;
+		if (commit.header) return commit.header.match(ANALYSIS_PATTERNS.SCOPE_HEADER)?.[1] ?? null;
+		return null;
+	}
+	/**
+	* Analyzes the commit scope for breaking changes based on configuration.
+	*
+	* @param commit - The commit to analyze
+	* @param config - The commit type configuration
+	* @returns An array of scopes that indicate breaking changes
+	*/
+	analyzeScopeBreaking(commit, config) {
+		const scope = this.extractCommitScope(commit);
+		if (!scope) return [];
+		if (config.scopeRules[scope.toLowerCase()] === "major") return [scope];
+		return [];
+	}
+	/**
+	* Detects if the commit indicates a pre-release to stable transition.
+	*
+	* @param commit - The commit to analyze
+	* @returns True if a transition is detected, false otherwise
+	*/
+	detectPreReleaseTransition(commit) {
+		const message = commit.header?.toLowerCase() ?? "";
+		const body = commit.body?.toLowerCase() ?? "";
+		return TRANSITION_KEYWORDS.some((keyword) => message.includes(keyword) || body.includes(keyword));
+	}
+	/**
+	* Performs a detailed analysis of the commits to determine their impact on versioning.
+	*
+	* @param commits - The list of commits to analyze
+	* @param config - The commit type configuration
+	* @returns The detailed commit analysis
+	*/
+	performDetailedAnalysis(commits, config) {
+		logger.verbose("CommitAnalysisService: Performing detailed commit analysis...");
+		const analysis = commits.reduce((acc, commit) => {
+			const type = commit.type?.toLowerCase() ?? "unknown";
+			const updatedCommitsByType = { ...acc.commitsByType };
+			if (!updatedCommitsByType[type]) updatedCommitsByType[type] = [];
+			updatedCommitsByType[type] = [...updatedCommitsByType[type], commit];
+			return {
+				breakingChanges: acc.breakingChanges + this.countBreakingChanges(commit),
+				features: acc.features + (this.isFeatureCommit(commit, config) ? 1 : 0),
+				patches: acc.patches + (this.isPatchCommit(commit, config) ? 1 : 0),
+				scopedBreaking: [...acc.scopedBreaking, ...this.analyzeScopeBreaking(commit, config)],
+				hasPreReleaseTransition: acc.hasPreReleaseTransition || this.detectPreReleaseTransition(commit),
+				commitsByType: updatedCommitsByType
+			};
+		}, {
+			breakingChanges: 0,
+			features: 0,
+			patches: 0,
+			scopedBreaking: [],
+			hasPreReleaseTransition: false,
+			commitsByType: {}
+		});
+		logger.verbose(`CommitAnalysisService: Analysis results - Breaking: ${analysis.breakingChanges}, Features: ${analysis.features}, Patches: ${analysis.patches}`);
+		return analysis;
+	}
+	/**
+	* Determines the version level based on the commit analysis.
+	*
+	* @param analysis - The detailed commit analysis
+	* @returns The recommended version level
+	*/
+	determineVersionLevel(analysis) {
+		logger.verbose("CommitAnalysisService: Determining version level from analysis...");
+		if (analysis.breakingChanges > 0 || analysis.scopedBreaking.length > 0) {
+			logger.verbose("CommitAnalysisService: Breaking changes detected, recommending MAJOR version bump.");
+			return VERSION_LEVELS.MAJOR;
+		}
+		if (analysis.features > 0) {
+			logger.verbose("CommitAnalysisService: New features detected, recommending MINOR version bump.");
+			return VERSION_LEVELS.MINOR;
+		}
+		if (analysis.patches > 0) {
+			logger.verbose("CommitAnalysisService: Patch-level changes detected, recommending PATCH version bump.");
+			return VERSION_LEVELS.PATCH;
+		}
+		logger.verbose("CommitAnalysisService: No significant changes detected, defaulting to PATCH version bump.");
+		return VERSION_LEVELS.PATCH;
+	}
+	/**
+	* Generates a human-readable reason for the version recommendation.
+	*
+	* @param analysis - The detailed commit analysis
+	* @returns A string explaining the recommendation
+	*/
+	generateRecommendationReason(analysis) {
+		const reasonParts = [];
+		if (analysis.breakingChanges > 0) {
+			const plural = analysis.breakingChanges === 1 ? "change" : "changes";
+			reasonParts.push(`${analysis.breakingChanges} breaking ${plural}`);
+		}
+		if (analysis.scopedBreaking.length > 0) {
+			const scopes = analysis.scopedBreaking.join(", ");
+			reasonParts.push(`breaking scope(s): ${scopes}`);
+		}
+		if (analysis.features > 0) {
+			const plural = analysis.features === 1 ? "feature" : "features";
+			reasonParts.push(`${analysis.features} new ${plural}`);
+		}
+		if (analysis.patches > 0) {
+			const plural = analysis.patches === 1 ? "fix" : "fixes";
+			reasonParts.push(`${analysis.patches} ${plural}`);
+		}
+		if (analysis.hasPreReleaseTransition) reasonParts.push("pre-release transition detected");
+		if (reasonParts.length === 0) return "No significant changes detected, defaulting to patch increment";
+		return `Analysis found: ${reasonParts.join(", ")}`;
+	}
+	/**
+	* Creates a default patch recommendation when no commits are provided.
+	*
+	* @returns The default version recommendation
+	*/
+	createDefaultPatchRecommendation() {
+		return {
+			level: VERSION_LEVELS.PATCH,
+			releaseType: "patch",
+			reason: "No commits provided, defaulting to patch increment for safety",
+			analysis: {
+				breakingChanges: 0,
+				features: 0,
+				patches: 0,
+				scopedBreaking: [],
+				hasPreReleaseTransition: false,
+				commitsByType: {}
+			}
+		};
+	}
+	/**
+	* Builds the final version recommendation object.
+	*
+	* @param level - The determined version level
+	* @param analysis - The detailed commit analysis
+	* @returns The version recommendation
+	*/
+	buildVersionRecommendation(level, analysis) {
+		logger.verbose("CommitAnalysisService: Building version recommendation...");
+		return {
+			level,
+			releaseType: LEVEL_TO_RELEASE_TYPE[level],
+			reason: this.generateRecommendationReason(analysis),
+			analysis
+		};
+	}
+};
+/**
+* Creates a commit analysis service instance.
+* @param git - The Git service to use
+*/
+function createCommitAnalysisService(git) {
+	return new DefaultCommitAnalysisService(git);
+}
+
+//#endregion
+export { createCommitAnalysisService };

package/dist/{dry-run-BfYCtldz.js → dry-run-korHDlWr.js}

@@ -1,5 +1,5 @@
 import { t as logger } from "./main.js";
-import { i as FireflyOkAsync } from "./result.constructors-C9M1MP3_.js";
+import { i as FireflyOkAsync } from "./result.constructors-D9jmQ0uj.js";
 
 //#region src/infrastructure/dry-run/index.ts
 /**

package/dist/{filesystem.service-9VHML130.js → filesystem.service-BcQtLzfl.js}

@@ -1,7 +1,7 @@
 import { t as logger } from "./main.js";
-import { c as notFoundErrAsync } from "./result.constructors-C9M1MP3_.js";
-import { n as wrapPromise } from "./result.utilities-DC5shlhT.js";
-import { t as withDryRun } from "./dry-run-BfYCtldz.js";
+import { l as notFoundErrAsync } from "./result.constructors-D9jmQ0uj.js";
+import { n as wrapPromise } from "./result.utilities-CdBL5noX.js";
+import { t as withDryRun } from "./dry-run-korHDlWr.js";
 
 //#region src/services/implementations/filesystem.service.ts
 /**

package/dist/{git.service-CACrfCW8.js → git.service-D1Mf6LZ0.js}

@@ -1,6 +1,6 @@
 import { t as logger } from "./main.js";
-import { i as FireflyOkAsync, m as failedError, o as failedErrAsync } from "./result.constructors-C9M1MP3_.js";
-import { t as withDryRun } from "./dry-run-BfYCtldz.js";
+import { h as failedError, i as FireflyOkAsync, o as failedErrAsync } from "./result.constructors-D9jmQ0uj.js";
+import { t as withDryRun } from "./dry-run-korHDlWr.js";
 import { ResultAsync } from "neverthrow";
 import { z } from "zod";
 

package/dist/main.js

@@ -71,7 +71,7 @@ const logger = createConsola({
 
 //#endregion
 //#region package.json
-var version = "4.0.0-dev.c94480d";
+var version = "4.0.0-dev.df58d2b";
 var description = " CLI orchestrator for automatic semantic versioning, changelog generation, and creating releases. Built for my own use cases.";
 var dependencies = {
 	"c12": "^3.3.2",
@@ -99,7 +99,7 @@ async function main() {
 		description,
 		gitCliffVersion: dependencies["git-cliff"]?.replace("^", "") || "unknown"
 	});
-	const { createFireflyCLI } = await import("./program-DcCz3-Sc.js");
+	const { createFireflyCLI } = await import("./program-CW3hIbzh.js");
 	createFireflyCLI().parseAsync(process.argv).catch((error) => {
 		logger.error("Fatal error:", error);
 		process.exit(1);

package/dist/{package-json.service-DACeZzRg.js → package-json.service-BKbXaHXQ.js}

@@ -1,6 +1,6 @@
 import { t as logger } from "./main.js";
-import { d as validationErrAsync, g as toFireflyError, i as FireflyOkAsync, u as validationErr } from "./result.constructors-C9M1MP3_.js";
-import { n as parseSchema } from "./schema.utilities-BGd9t1wm.js";
+import { d as validationErr, f as validationErrAsync, i as FireflyOkAsync, v as toFireflyError } from "./result.constructors-D9jmQ0uj.js";
+import { n as parseSchema } from "./schema.utilities-BOJqWEey.js";
 import { Result } from "neverthrow";
 import z$1 from "zod";
 

package/dist/{program-DcCz3-Sc.js → program-CW3hIbzh.js}

@@ -1,7 +1,7 @@
 import { n as RuntimeEnv, t as logger } from "./main.js";
-import { _ as validationError, a as conflictErrAsync, c as notFoundErrAsync, d as validationErrAsync, f as conflictError, h as notFoundError, i as FireflyOkAsync, l as timeoutErrAsync, m as failedError, n as FireflyErrAsync, r as FireflyOk, s as invalidErr, t as FireflyErr, u as validationErr, v as wrapErrorMessage } from "./result.constructors-C9M1MP3_.js";
-import { n as wrapPromise, r as zip3Async, t as ensureNotAsync } from "./result.utilities-DC5shlhT.js";
-import { n as parseSchema, t as formatZodErrors } from "./schema.utilities-BGd9t1wm.js";
+import { _ as notFoundError, a as conflictErrAsync, b as wrapErrorMessage, c as invalidErrAsync, d as validationErr, f as validationErrAsync, h as failedError, i as FireflyOkAsync, l as notFoundErrAsync, n as FireflyErrAsync, p as conflictError, r as FireflyOk, s as invalidErr, t as FireflyErr, u as timeoutErrAsync, y as validationError } from "./result.constructors-D9jmQ0uj.js";
+import { n as wrapPromise, r as zip3Async, t as ensureNotAsync } from "./result.utilities-CdBL5noX.js";
+import { n as parseSchema, t as formatZodErrors } from "./schema.utilities-BOJqWEey.js";
 import { LogLevels } from "consola";
 import { colors } from "consola/utils";
 import { Command } from "commander";
@@ -1003,9 +1003,10 @@ function createBumpExecutionGroup() {
 */
 function shouldSkipBumpStrategy(ctx) {
 	const { skipBump, releaseType, bumpStrategy } = ctx.config;
+	const { selectedReleaseType, selectedBumpStrategy } = ctx.data;
 	if (skipBump) return true;
-	if (releaseType) return true;
-	if (!bumpStrategy) return true;
+	if (releaseType || selectedReleaseType) return true;
+	if (!Boolean(bumpStrategy || selectedBumpStrategy)) return true;
 	return false;
 }
 /**
@@ -1013,9 +1014,11 @@ function shouldSkipBumpStrategy(ctx) {
 */
 function getSkipReason(ctx) {
 	const { skipBump, releaseType, bumpStrategy } = ctx.config;
+	const { selectedReleaseType, selectedBumpStrategy } = ctx.data;
 	if (skipBump) return "skipBump is enabled";
-	if (releaseType) return `releaseType already set to '${releaseType}'`;
-	if (!bumpStrategy) return "no bumpStrategy configured";
+	if (releaseType) return `releaseType already set to '${releaseType}' (config)`;
+	if (selectedReleaseType) return `releaseType already set to '${selectedReleaseType}' (data)`;
+	if (!Boolean(bumpStrategy || selectedBumpStrategy)) return "no bumpStrategy configured";
 	return "unknown reason";
 }
 function createDelegateBumpStrategyTask() {
@@ -1034,7 +1037,10 @@ function createDelegateBumpStrategyTask() {
 //#endregion
 //#region src/commands/release/tasks/determine-automatic-bump.task.ts
 function createDetermineAutomaticBump() {
-	return TaskBuilder.create("determine-automatic-bump").description("Automatically determines the version bump from commit messages").dependsOn("delegate-bump-strategy").skipWhenWithReason((ctx) => ctx.config.skipBump || ctx.config.bumpStrategy !== BUMP_STRATEGY_AUTO, "Skipped: skipBump enabled or bumpStrategy is not 'auto'").execute((ctx) => {
+	return TaskBuilder.create("determine-automatic-bump").description("Automatically determines the version bump from commit messages").dependsOn("delegate-bump-strategy").skipWhenWithReason((ctx) => {
+		const bumpStrategy = ctx.data.selectedBumpStrategy ?? ctx.config.bumpStrategy;
+		return ctx.config.skipBump || bumpStrategy !== BUMP_STRATEGY_AUTO;
+	}, "Skipped: skipBump enabled or bumpStrategy is not 'auto'").execute((ctx) => {
 		logger.info("determine-automatic-bump");
 		return FireflyOkAsync(ctx);
 	}).build();
@@ -1042,17 +1048,61 @@ function createDetermineAutomaticBump() {
 
 //#endregion
 //#region src/commands/release/tasks/prompt-bump-strategy.task.ts
+const BUMP_STRATEGIES = [{
+	label: "Automatic Bump",
+	value: BUMP_STRATEGY_AUTO,
+	hint: "Determines the next version based on conventional commits history"
+}, {
+	label: "Manual Bump",
+	value: BUMP_STRATEGY_MANUAL,
+	hint: "Manually specify the next version"
+}];
+const VALID_STRATEGY_VALUES = BUMP_STRATEGIES.map((s) => s.value);
+/**
+* Validates that the selected strategy is one of the allowed values.
+*
+* @param strategy The selected version bump strategy.
+* @returns A FireflyResult indicating success or failure of validation.
+*/
+function validateStrategy(strategy) {
+	if (!VALID_STRATEGY_VALUES.includes(strategy)) return invalidErr({ message: `Invalid version bump strategy: ${strategy}` });
+	return FireflyOk(strategy);
+}
+/**
+* Prompts the user to select a bump strategy using the logger's prompt API.
+*/
+function promptBumpStrategy() {
+	const defaultStrategy = BUMP_STRATEGIES[0];
+	if (!defaultStrategy) return notFoundErrAsync({ message: "No default version bump strategy found" });
+	logger.verbose("PromptBumpStrategyTask: Prompting user for version bump strategy.");
+	const prompt = logger.prompt("Select version bump strategy", {
+		type: "select",
+		options: BUMP_STRATEGIES,
+		initial: defaultStrategy.value,
+		cancel: "reject"
+	});
+	if (logger.level !== LogLevels.verbose) logger.log("");
+	return wrapPromise(prompt).andTee(() => {
+		if (logger.level === LogLevels.verbose) logger.log("");
+	}).andThen((selected) => {
+		if (!selected || selected === "") return invalidErrAsync({ message: "No version bump strategy selected" });
+		const validationResult = validateStrategy(selected);
+		if (validationResult.isErr()) return FireflyErrAsync(validationResult.error);
+		logger.verbose(`PromptBumpStrategyTask: Selected version bump strategy: '${selected}'`);
+		return FireflyOkAsync(selected);
+	});
+}
 function createPromptBumpStrategyTask() {
-	return TaskBuilder.create("prompt-bump-strategy").description("Prompts the user for a version bump strategy").dependsOn("initialize-release-version").skipWhenWithReason((ctx) => ctx.config.skipBump || Boolean(ctx.config.bumpStrategy) || Boolean(ctx.config.releaseType), "Skipped: skipBump enabled, or bumpStrategy/releaseType already specified").execute((ctx) => {
-		logger.info("prompt-bump-strategy");
-		return FireflyOkAsync(ctx);
-	}).build();
+	return TaskBuilder.create("prompt-bump-strategy").description("Prompts the user for a version bump strategy").dependsOn("initialize-release-version").skipWhenWithReason((ctx) => ctx.config.skipBump || Boolean(ctx.config.bumpStrategy) || Boolean(ctx.config.releaseType), "Skipped: skipBump enabled, or bumpStrategy/releaseType already specified").execute((ctx) => promptBumpStrategy().andThen((strategy) => FireflyOkAsync(ctx.fork("selectedBumpStrategy", strategy)))).build();
 }
 
 //#endregion
 //#region src/commands/release/tasks/prompt-manual-bump.task.ts
 function createPromptManualVersionTask() {
-	return TaskBuilder.create("prompt-manual-version").description("Prompts the user for a manual version bump selections").dependsOn("delegate-bump-strategy").skipWhenWithReason((ctx) => ctx.config.skipBump || Boolean(ctx.config.bumpStrategy) || Boolean(ctx.config.releaseType), "Skipped: skipBump enabled, or bumpStrategy/releaseType already specified").execute((ctx) => {
+	return TaskBuilder.create("prompt-manual-version").description("Prompts the user for a manual version bump selections").dependsOn("delegate-bump-strategy").skipWhenWithReason((ctx) => {
+		const bumpStrategy = ctx.data.selectedBumpStrategy ?? ctx.config.bumpStrategy;
+		return ctx.config.skipBump || bumpStrategy !== BUMP_STRATEGY_MANUAL;
+	}, "Skipped: skipBump enabled or bumpStrategy is not 'manual'").execute((ctx) => {
 		logger.info("prompt-manual-version");
 		return FireflyOkAsync(ctx);
 	}).build();
@@ -1611,21 +1661,41 @@ function defineService(definition) {
 */
 const SERVICE_DEFINITIONS = {
 	fs: defineService({ factory: async ({ basePath }) => {
-		const { createFileSystemService } = await import("./filesystem.service-9VHML130.js");
+		const { createFileSystemService } = await import("./filesystem.service-BcQtLzfl.js");
 		return createFileSystemService(basePath);
 	} }),
 	packageJson: defineService({
 		dependencies: ["fs"],
 		factory: async ({ getService }) => {
 			const fs = await getService("fs");
-			const { createPackageJsonService } = await import("./package-json.service-DACeZzRg.js");
+			const { createPackageJsonService } = await import("./package-json.service-BKbXaHXQ.js");
 			return createPackageJsonService(fs);
 		}
 	}),
 	git: defineService({ factory: async ({ basePath }) => {
-		const { createGitService } = await import("./git.service-CACrfCW8.js");
+		const { createGitService } = await import("./git.service-D1Mf6LZ0.js");
 		return createGitService(basePath);
-	} })
+	} }),
+	versionBumper: defineService({ factory: async () => {
+		const { createVersionBumperService } = await import("./version-bumper.service-CvPx7EZx.js");
+		return createVersionBumperService();
+	} }),
+	versionStrategy: defineService({
+		dependencies: ["versionBumper"],
+		factory: async ({ getService }) => {
+			const versionBumper = await getService("versionBumper");
+			const { createVersionStrategyService } = await import("./version-strategy.service-BO_7MY5O.js");
+			return createVersionStrategyService(versionBumper);
+		}
+	}),
+	commitAnalysis: defineService({
+		dependencies: ["git"],
+		factory: async ({ getService }) => {
+			const git = await getService("git");
+			const { createCommitAnalysisService } = await import("./commit-analysis.service-CtIh7eez.js");
+			return createCommitAnalysisService(git);
+		}
+	})
 };
 /**
 * Array of all service keys for iteration

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-CdBL5noX.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

package/dist/{schema.utilities-BGd9t1wm.js → schema.utilities-BOJqWEey.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-bumper.service-CvPx7EZx.js

@@ -0,0 +1,318 @@
+import { r as FireflyOk, s as invalidErr, t as FireflyErr } 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 prereleaseIdentifier() {
+		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
+//#region src/services/implementations/version-bumper.service.ts
+/**
+* Default implementation of the version bumper service.
+*/
+var DefaultVersionBumperService = class {
+	bump(options) {
+		const { currentVersion, releaseType, prereleaseIdentifier, prereleaseBase } = options;
+		if (releaseType === "major" || releaseType === "minor" || releaseType === "patch") return this.bumpStandard(currentVersion, releaseType);
+		if (releaseType === "premajor" || releaseType === "preminor" || releaseType === "prepatch") return this.bumpPreStandard(currentVersion, releaseType, prereleaseIdentifier, prereleaseBase);
+		if (releaseType === "prerelease") return this.bumpPrerelease(currentVersion, prereleaseIdentifier, prereleaseBase);
+		if (releaseType === "graduate") return this.graduatePrerelease(currentVersion);
+		return invalidErr({
+			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 prerelease base '${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, identifier, base) {
+		const normalizedBaseResult = this.normalizeBase(base);
+		if (normalizedBaseResult.isErr()) return FireflyErr(normalizedBaseResult.error);
+		const normalizedBase = normalizedBaseResult.value;
+		let newVersionString = null;
+		if (normalizedBase !== void 0) newVersionString = identifier ? semver.inc(currentVersion.raw, releaseType, identifier, normalizedBase) : semver.inc(currentVersion.raw, releaseType, void 0, normalizedBase);
+		else newVersionString = identifier ? semver.inc(currentVersion.raw, releaseType, identifier) : semver.inc(currentVersion.raw, releaseType);
+		if (!newVersionString) return invalidErr({
+			message: `Failed to bump ${releaseType} version from '${currentVersion.raw}' with identifier '${identifier}' and base '${base}'.`,
+			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, identifier, base) {
+		let newVersionString = null;
+		if (this.isComplexIdentifier(identifier)) newVersionString = this.bumpWithComplexIdentifier(currentVersion, identifier);
+		else if (base !== void 0 && base !== null) {
+			const normalizedBaseResult = this.normalizeBase(base);
+			if (normalizedBaseResult.isErr()) return FireflyErr(normalizedBaseResult.error);
+			const normalizedBase = normalizedBaseResult.value;
+			newVersionString = identifier ? semver.inc(currentVersion.raw, "prerelease", identifier, normalizedBase) : semver.inc(currentVersion.raw, "prerelease", void 0, normalizedBase);
+		} else if (currentVersion.isPrerelease) newVersionString = this.bumpExistingPrerelease(currentVersion, identifier);
+		else {
+			const defaultIdentifier = identifier || "alpha";
+			newVersionString = semver.inc(currentVersion.raw, "prerelease", defaultIdentifier);
+		}
+		if (!newVersionString) return invalidErr({
+			message: `Failed to bump prerelease version from '${currentVersion.raw}' with identifier '${identifier}' and base '${base}'.`,
+			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-BO_7MY5O.js

@@ -0,0 +1,4 @@
+import "./result.constructors-D9jmQ0uj.js";
+import { n as TRANSITION_KEYWORDS, r as createVersionStrategyService, t as DefaultVersionStrategyService } from "./version-strategy.service-vh5KeNCA.js";
+
+export { createVersionStrategyService };

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

@@ -0,0 +1,258 @@
+import { t as logger } from "./main.js";
+import { g as invalidError, r as FireflyOk, t as FireflyErr } from "./result.constructors-D9jmQ0uj.js";
+import { Result } 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."
+};
+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,
+				prereleaseIdentifier: options.prereleaseIdentifier,
+				prereleaseBase: options.prereleaseBase
+			});
+		}
+		return FireflyErr(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.prereleaseIdentifier, options.prereleaseBase));
+		const combinedResult = Result.combine(choicesResults);
+		if (combinedResult.isErr()) return FireflyErr(combinedResult.error);
+		logger.verbose(`DefaultVersionStrategyService: Created ${combinedResult.value.length} version choices.`);
+		return FireflyOk(combinedResult.value);
+	}
+	/**
+	* 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,
+			prereleaseIdentifier: currentVersion.prereleaseIdentifier,
+			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",
+			prereleaseIdentifier: options.prereleaseIdentifier ?? context.prereleaseIdentifier ?? "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 FireflyErr(invalidError({
+			message: "Cannot transition to stable version without recommendation",
+			source: "services/version-strategy"
+		}));
+		const graduateResult = this.bumper.bump({
+			currentVersion: options.currentVersion,
+			releaseType: "graduate"
+		});
+		if (graduateResult.isErr()) return FireflyErr(graduateResult.error);
+		const stableVersion = graduateResult.value;
+		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 FireflyOk(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",
+				prereleaseIdentifier: options.prereleaseIdentifier ?? context.prereleaseIdentifier ?? "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,
+			prereleaseIdentifier: options.prereleaseIdentifier,
+			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 prereleaseIdentifier - Optional pre-release identifier
+	* @param prereleaseBase - Optional base for pre-release
+	* @returns A result containing the version choice or an error
+	*/
+	createSingleChoice(currentVersion, releaseType, prereleaseIdentifier, prereleaseBase) {
+		const bumpOptions = {
+			currentVersion,
+			releaseType,
+			prereleaseIdentifier,
+			prereleaseBase
+		};
+		const newVersionResult = this.bumper.bump(bumpOptions);
+		if (newVersionResult.isErr()) return FireflyErr(newVersionResult.error);
+		const newVersion = newVersionResult.value;
+		return FireflyOk({
+			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 as n, createVersionStrategyService as r, DefaultVersionStrategyService as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fireflyy",
-  "version": "4.0.0-dev.c94480d",
+  "version": "4.0.0-dev.df58d2b",
   "description": " CLI orchestrator for automatic semantic versioning, changelog generation, and creating releases. Built for my own use cases.",
   "type": "module",
   "license": "MIT",