fireflyy 4.0.0-dev.4721ae4 → 4.0.0-dev.5da9e52

package/dist/{git.service-DarjfyXF.js → git.service-C0qRXy1s.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-BeuzUufT.js";
 import { ResultAsync } from "neverthrow";
 import { z } from "zod";
 
@@ -257,7 +257,7 @@ var DefaultGitService = class {
 		return this.git(["rev-parse", "--is-inside-work-tree"]).map(() => true).orElse(() => FireflyOkAsync(false));
 	}
 	getRepositoryRoot() {
-		return this.git(["rev-parse", "--show-toplevel"]).map((output) => output.trim());
+		return this.git(["rev-parse", "--show-toplevel"]).andTee(() => logger.verbose("DefaultGitService: Resolving repository root")).map((output) => output.trim()).andTee(() => logger.verbose("DefaultGitService: Repository root resolved"));
 	}
 	getRemoteUrl(remote) {
 		const remoteName = remote ?? "origin";
@@ -280,12 +280,14 @@ var DefaultGitService = class {
 				else if (index !== " " && index !== "?") hasStaged = true;
 				if (workTree !== " " && workTree !== "?") hasUnstaged = true;
 			}
-			return {
+			const status = {
 				hasStaged,
 				hasUnstaged,
 				hasUntracked,
 				isClean: lines.length === 0
 			};
+			logger.verbose(`DefaultGitService: Git status: staged=${status.hasStaged},unstaged=${status.hasUnstaged},untracked=${status.hasUntracked},clean=${status.isClean}`);
+			return status;
 		});
 	}
 	isWorkingTreeClean() {
@@ -312,7 +314,7 @@ var DefaultGitService = class {
 		const includeStaged = filter?.staged ?? true;
 		const includeUnstaged = filter?.unstaged ?? true;
 		return this.git(["status", "--porcelain"]).map((output) => {
-			return this.parseStatusOutput(output).filter((file) => {
+			const filtered = this.parseStatusOutput(output).filter((file) => {
 				const isStaged = file.indexStatus !== " " && file.indexStatus !== "?";
 				const isUnstaged = file.workTreeStatus !== " " && file.workTreeStatus !== "?";
 				if (includeStaged && includeUnstaged) return isStaged || isUnstaged;
@@ -320,6 +322,8 @@ var DefaultGitService = class {
 				if (includeUnstaged) return isUnstaged;
 				return false;
 			});
+			logger.verbose(`DefaultGitService: Found ${filtered.length} file(s) for filter staged=${includeStaged} unstaged=${includeUnstaged}`);
+			return filtered;
 		});
 	}
 	getFileNames(filter) {
@@ -344,11 +348,13 @@ var DefaultGitService = class {
 		const isRemote = line.includes("remotes/");
 		let branchName = line.replace(CURRENT_BRANCH_MARKER_REGEX, "").trim();
 		if (isRemote) branchName = branchName.replace(REMOTES_PREFIX_REGEX, "");
-		return {
+		const branch = {
 			name: branchName,
 			isCurrent,
 			isRemote
 		};
+		logger.verbose(`DefaultGitService: Parsed branch: ${branch.name} current=${branch.isCurrent} remote=${branch.isRemote}`);
+		return branch;
 	}
 	listBranches(includeRemote) {
 		const args = ["branch"];
@@ -359,7 +365,7 @@ var DefaultGitService = class {
 	}
 	createCommit(message, options) {
 		if (options?.dryRun) {
-			logger.verbose("GitService: Dry run, skipping commit");
+			logger.verbose("DefaultGitService: Dry run, skipping commit");
 			return FireflyOkAsync({ sha: "dry-run-sha" });
 		}
 		const args = [
@@ -402,6 +408,7 @@ var DefaultGitService = class {
 				`${upstream}..HEAD`
 			]).map((output) => {
 				const count = Number.parseInt(output.trim(), 10) || 0;
+				logger.verbose(`DefaultGitService: Unpushed commits count for ${upstream}: ${count}`);
 				return {
 					hasUnpushed: count > 0,
 					count
@@ -413,6 +420,7 @@ var DefaultGitService = class {
 					"HEAD"
 				]).map((output) => {
 					const count = Number.parseInt(output.trim(), 10) || 0;
+					logger.verbose(`DefaultGitService: Total commit count: ${count}`);
 					return {
 						hasUnpushed: count > 0,
 						count
@@ -426,7 +434,7 @@ var DefaultGitService = class {
 	}
 	createTag(name, options) {
 		if (options?.dryRun) {
-			logger.verbose(`GitService: Dry run, skipping tag creation: ${name}`);
+			logger.verbose(`DefaultGitService: Dry run, skipping tag creation: ${name}`);
 			return FireflyOkAsync(void 0);
 		}
 		const args = ["tag"];
@@ -439,7 +447,7 @@ var DefaultGitService = class {
 		const scope = options?.scope ?? "local";
 		const remote = options?.remote ?? "origin";
 		if (options?.dryRun) {
-			logger.verbose(`GitService: Dry run, skipping tag deletion (${scope}): ${name}`);
+			logger.verbose(`DefaultGitService: Dry run, skipping tag deletion (${scope}): ${name}`);
 			return FireflyOkAsync(void 0);
 		}
 		if (scope === "local") return this.git([
@@ -447,11 +455,15 @@ var DefaultGitService = class {
 			"-d",
 			name
 		]).map(() => void 0);
-		if (scope === "remote") return this.git([
-			"push",
-			remote,
-			`:refs/tags/${name}`
-		]).map(() => void 0);
+		if (scope === "remote") {
+			logger.verbose(`DefaultGitService: Deleting remote tag: ${name} on ${remote}`);
+			return this.git([
+				"push",
+				remote,
+				`:refs/tags/${name}`
+			]).andTee(() => logger.verbose(`DefaultGitService: Remote tag deleted: ${name} on ${remote}`)).map(() => void 0);
+		}
+		logger.verbose(`DefaultGitService: Deleting tag locally and remotely: ${name} on ${remote}`);
 		return this.git([
 			"tag",
 			"-d",
@@ -460,17 +472,21 @@ var DefaultGitService = class {
 			"push",
 			remote,
 			`:refs/tags/${name}`
-		])).map(() => void 0);
+		])).andTee(() => logger.verbose(`DefaultGitService: Local and remote tag deleted: ${name} on ${remote}`)).map(() => void 0);
 	}
 	hasTag(name) {
 		return this.git([
 			"tag",
 			"--list",
 			name
-		]).map((output) => output.trim() === name);
+		]).map((output) => {
+			const exists = output.trim() === name;
+			logger.verbose(`DefaultGitService: Tag ${name} exists=${exists}`);
+			return exists;
+		});
 	}
 	hasAnyTags() {
-		return this.getLatestTag().map((tag) => tag !== null);
+		return this.getLatestTag().andTee(() => logger.verbose("DefaultGitService: Checking if any tags exist")).map((tag) => tag !== null);
 	}
 	listTags() {
 		return this.git(["tag", "--list"]).map((output) => output.split("\n").map((tag) => tag.trim()).filter((tag) => tag.length > 0));
@@ -494,25 +510,28 @@ var DefaultGitService = class {
 			"--format=%(contents)",
 			name
 		]).map((output) => {
-			return output.trim() || null;
+			const message = output.trim();
+			logger.verbose(`DefaultGitService: Tag message for ${name}: ${message?.substring(0, 60) ?? "(none)"}`);
+			return message || null;
 		}).orElse(() => FireflyOkAsync(null));
 	}
 	stage(paths) {
 		const pathArray = Array.isArray(paths) ? paths : [paths];
-		return this.git(["add", ...pathArray]).map(() => void 0);
+		return this.git(["add", ...pathArray]).andTee(() => logger.verbose(`DefaultGitService: Staged paths: ${pathArray.join(", ")}`)).map(() => void 0);
 	}
 	unstage(paths) {
 		const pathArray = Array.isArray(paths) ? paths : [paths];
+		logger.verbose(`DefaultGitService: Unstaging paths: ${pathArray.join(", ")}`);
 		return this.git([
 			"reset",
 			"HEAD",
 			"--",
 			...pathArray
-		]).map(() => void 0);
+		]).andTee(() => logger.verbose(`DefaultGitService: Unstaged paths: ${pathArray.join(", ")}`)).map(() => void 0);
 	}
 	push(options) {
 		if (options?.dryRun) {
-			logger.verbose("GitService: Dry run, skipping push");
+			logger.verbose("DefaultGitService: Dry run, skipping push");
 			return FireflyOkAsync(void 0);
 		}
 		const args = ["push"];
@@ -550,9 +569,10 @@ var DefaultGitService = class {
 	inferRepositoryUrl() {
 		return this.getUpstreamRemote().andThen((upstreamRemote) => {
 			if (upstreamRemote) {
-				logger.verbose(`GitService: Inferring repository URL from upstream remote: ${upstreamRemote}`);
+				logger.verbose(`DefaultGitService: Inferring repository URL from upstream remote: ${upstreamRemote}`);
 				return this.getRemoteUrl(upstreamRemote).map((url) => url).orElse(() => this.tryOriginOrFirstRemote());
 			}
+			logger.verbose("DefaultGitService: No upstream remote; falling back to origin or first remote");
 			return this.tryOriginOrFirstRemote();
 		});
 	}
@@ -561,16 +581,16 @@ var DefaultGitService = class {
 	*/
 	tryOriginOrFirstRemote() {
 		return this.getRemoteUrl("origin").map((url) => {
-			logger.verbose("GitService: Inferring repository URL from origin remote");
+			logger.verbose("DefaultGitService: Inferring repository URL from origin remote");
 			return url;
 		}).orElse(() => {
 			return this.listRemotes().andThen((remotes) => {
 				if (remotes.length === 0) {
-					logger.verbose("GitService: No remotes configured, cannot infer repository URL");
+					logger.verbose("DefaultGitService: No remotes configured, cannot infer repository URL");
 					return FireflyOkAsync(null);
 				}
 				const firstRemote = remotes[0];
-				logger.verbose(`GitService: Inferring repository URL from first remote: ${firstRemote}`);
+				logger.verbose(`DefaultGitService: Inferring repository URL from first remote: ${firstRemote}`);
 				return this.getRemoteUrl(firstRemote).map((url) => url).orElse(() => FireflyOkAsync(null));
 			});
 		});

package/dist/main.js

@@ -71,7 +71,7 @@ const logger = createConsola({
 
 //#endregion
 //#region package.json
-var version = "4.0.0-dev.4721ae4";
+var version = "4.0.0-dev.5da9e52";
 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-Cw3A_k7R.js");
+	const { createFireflyCLI } = await import("./program-5IEws7yO.js");
 	createFireflyCLI().parseAsync(process.argv).catch((error) => {
 		logger.error("Fatal error:", error);
 		process.exit(1);

package/dist/{package-json.service-QN7SzRTt.js → package-json.service-B6ultpL4.js}

@@ -1,5 +1,6 @@
-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 { t as logger } from "./main.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";
 
@@ -28,7 +29,7 @@ var DefaultPackageJsonService = class DefaultPackageJsonService {
 		return this.fs.read(path).map((content) => this.replaceVersionInContent(content, newVersion)).andThen((updatedContent) => this.fs.write(path, updatedContent)).andThen(() => this.read(path).andThen((pkg) => {
 			if (pkg.version !== newVersion) return validationErrAsync({ message: `Failed to verify updated version in package.json at path: ${path}` });
 			return FireflyOkAsync(void 0);
-		}));
+		})).andTee(() => logger.verbose(`DefaultPackageJsonService: Updated version in package.json at path: ${path} to ${newVersion}`));
 	}
 	/**
 	* Replaces the version string in the package.json content.

package/dist/{program-Cw3A_k7R.js → program-5IEws7yO.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();
@@ -1091,11 +1141,36 @@ function createBumpStrategyGroup() {
 
 //#endregion
 //#region src/commands/release/tasks/initialize-release-version.task.ts
+const PACKAGE_JSON_FILE = "package.json";
+/**
+* Reads package.json and extracts the version field.
+*
+* Behavior:
+* - Reads the configured package.json file.
+* - If the version property is missing, returns a validation error.
+* - Otherwise resolves with the version string.
+*/
+function getVersionFromPackageJson(ctx) {
+	return ctx.services.packageJson.read(PACKAGE_JSON_FILE).andThen((pkg) => {
+		const version = pkg.version;
+		if (!version) return validationErrAsync({ message: "The 'version' field is missing in package.json." });
+		logger.verbose(`InitializeReleaseVersionTask: Prepared current version: ${version}`);
+		return FireflyOkAsync(version);
+	});
+}
+/**
+* Creates the Initialize Release Version task.
+*
+* This task initializes the current release version by reading it from package.json.
+*
+* This task:
+* 1. Reads the version from package.json
+*/
 function createInitializeReleaseVersion() {
-	return TaskBuilder.create("initialize-release-version").description("Hydrate and prepare the release configuration").dependsOn("prepare-release-config").execute((ctx) => {
-		logger.info("initialize-release-version");
-		return FireflyOkAsync(ctx);
-	}).build();
+	return TaskBuilder.create("initialize-release-version").description("Initialize current release version from package.json").dependsOn("prepare-release-config").execute((ctx) => getVersionFromPackageJson(ctx).andThen((currentVersion) => {
+		logger.info(`Current version is ${currentVersion}`);
+		return FireflyOkAsync(ctx.fork("currentVersion", currentVersion));
+	})).build();
 }
 
 //#endregion
@@ -1160,12 +1235,12 @@ function extractPreReleaseId(version) {
 * - Parses the URL and returns "owner/repo" when possible.
 */
 function hydrateRepository(ctx) {
-	return ctx.services.git.inferRepositoryUrl().map((url) => {
-		if (!url) return null;
+	return ctx.services.git.inferRepositoryUrl().andThen((url) => {
+		if (!url) return validationErrAsync({ message: "Could not determine git remote URL to infer repository information" });
 		const parsed = parseGitRemoteUrl(url);
-		if (parsed) return `${parsed.owner}/${parsed.repo}`;
-		return null;
-	}).map((val) => val ?? void 0).andTee((repository) => logger.verbose(`PrepareReleaseConfigTask: Prepared repository: ${repository}`));
+		if (parsed) return FireflyOkAsync(`${parsed.owner}/${parsed.repo}`);
+		return validationErrAsync({ message: `Could not parse repository information from git remote URL: ${url}` });
+	}).andTee((repository) => logger.verbose(`PrepareReleaseConfigTask: Prepared repository: ${repository}`));
 }
 /**
 * Hydrates name, scope, and preReleaseId from package.json.
@@ -1586,21 +1661,41 @@ function defineService(definition) {
 */
 const SERVICE_DEFINITIONS = {
 	fs: defineService({ factory: async ({ basePath }) => {
-		const { createFileSystemService } = await import("./filesystem.service-BeY7DXz3.js");
+		const { createFileSystemService } = await import("./filesystem.service-Bl5h9T_0.js");
 		return createFileSystemService(basePath);
 	} }),
 	packageJson: defineService({
 		dependencies: ["fs"],
 		factory: async ({ getService }) => {
 			const fs = await getService("fs");
-			const { createPackageJsonService } = await import("./package-json.service-QN7SzRTt.js");
+			const { createPackageJsonService } = await import("./package-json.service-B6ultpL4.js");
 			return createPackageJsonService(fs);
 		}
 	}),
 	git: defineService({ factory: async ({ basePath }) => {
-		const { createGitService } = await import("./git.service-DarjfyXF.js");
+		const { createGitService } = await import("./git.service-C0qRXy1s.js");
 		return createGitService(basePath);
-	} })
+	} }),
+	versionBumper: defineService({ factory: async () => {
+		const { createVersionBumperService } = await import("./version-bumper.service-BYsIFCpv.js");
+		return createVersionBumperService();
+	} }),
+	versionStrategy: defineService({
+		dependencies: ["versionBumper"],
+		factory: async ({ getService }) => {
+			const versionBumper = await getService("versionBumper");
+			const { createVersionStrategyService } = await import("./version-strategy.service-Ds4mvlDC.js");
+			return createVersionStrategyService(versionBumper);
+		}
+	}),
+	commitAnalysis: defineService({
+		dependencies: ["git"],
+		factory: async ({ getService }) => {
+			const git = await getService("git");
+			const { createCommitAnalysisService } = await import("./commit-analysis.service-BNlHyyhC.js");
+			return createCommitAnalysisService(git);
+		}
+	})
 };
 /**
 * Array of all service keys for iteration
@@ -2239,7 +2334,11 @@ var WorkflowExecutor = class {
 		const startTime = /* @__PURE__ */ new Date();
 		const executedTaskIds = [];
 		const skippedTaskIds = [];
-		if (this.options.dryRun) logger.warn("Workflow executing in DRY RUN mode - no actual changes will be made");
+		if (this.options.dryRun) logger.warn("Running in DRY-RUN mode: No changes will be made.");
+		const version = RuntimeEnv.version;
+		const dashIndex = version.indexOf("-");
+		if (dashIndex !== -1) if (dashIndex === version.length - 1 || version[dashIndex + 1] === "n") logger.warn(`You are running a DEVELOPMENT build of Firefly (${colors.dim(version)}). This is a 'next' build and may be unstable.`);
+		else logger.warn(`You are running a PRE-RELEASE version of Firefly (${colors.dim(version)}). Unexpected behavior or bugs may occur.`);
 		logger.verbose(`WorkflowExecutor: Starting execution of ${tasks.length} tasks`);
 		return this.executeTasksSequentially(tasks, initialContext, executedTaskIds, skippedTaskIds).andThen(() => this.buildExecutionSuccessResult(startTime, executedTaskIds, skippedTaskIds)).orElse((error) => this.handleExecutionFailure({
 			error,

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";