fireflyy 4.0.0-alpha.8 → 4.0.0-dev.25c80f6

package/assets/firefly.schema.json

@@ -35,6 +35,10 @@
           "default": "",
           "type": "string"
         },
+        "branch": {
+          "description": "Git branch to release from.",
+          "type": "string"
+        },
         "changelogPath": {
           "description": "Changelog file path, relative to project root.",
           "default": "CHANGELOG.md",

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

@@ -1,5 +1,6 @@
+import { t as logger } from "./main.js";
 import { c as notFoundErrAsync } from "./result.constructors-C9M1MP3_.js";
-import { n as wrapPromise } from "./result.utilities-oXWCXEvw.js";
+import { n as wrapPromise } from "./result.utilities-DC5shlhT.js";
 import { t as withDryRun } from "./dry-run-BfYCtldz.js";
 
 //#region src/services/implementations/filesystem.service.ts
@@ -29,21 +30,18 @@ var DefaultFileSystemService = class {
 	}
 	exists(path) {
 		const resolved = this.resolvePath(path);
-		return wrapPromise(Bun.file(resolved).exists());
+		return wrapPromise(Bun.file(resolved).exists()).andTee(() => logger.verbose(`DefaultFileSystemService: Checked existence of file: ${resolved}`));
 	}
 	read(path) {
 		const resolved = this.resolvePath(path);
 		const file = Bun.file(resolved);
 		return wrapPromise(file.exists()).andThen((fileExists) => {
-			if (!fileExists) return notFoundErrAsync({
-				message: `File not found: ${resolved}`,
-				source: "FileSystemService.read"
-			});
-			return wrapPromise(file.text());
+			if (!fileExists) return notFoundErrAsync({ message: `File not found: ${resolved}` });
+			return wrapPromise(file.text()).andTee(() => logger.verbose(`DefaultFileSystemService: Read file: ${resolved}`));
 		});
 	}
 	write(path, content, options) {
-		return withDryRun(options, `Writing to ${this.resolvePath(path)}`, () => wrapPromise(Bun.write(this.resolvePath(path), content).then(() => {})));
+		return withDryRun(options, `Writing to ${this.resolvePath(path)}`, () => wrapPromise(Bun.write(this.resolvePath(path), content).then(() => {})).andTee(() => logger.verbose(`DefaultFileSystemService: Wrote file: ${this.resolvePath(path)}`)));
 	}
 };
 /**

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

@@ -250,14 +250,14 @@ var DefaultGitService = class {
 		return executeGitCommand(args, {
 			cwd: this.cwd,
 			dryRun: options?.dryRun,
-			verbose: options?.verbose ?? false
+			verbose: options?.verbose ?? true
 		});
 	}
 	isInsideRepository() {
 		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"];
@@ -523,6 +542,59 @@ var DefaultGitService = class {
 		if (options?.followTags) args.push("--follow-tags");
 		return this.git(args).map(() => void 0);
 	}
+	/**
+	* Gets the upstream remote name for the current branch.
+	* @returns The remote name or null if no upstream is configured.
+	*/
+	getUpstreamRemote() {
+		return this.git([
+			"rev-parse",
+			"--abbrev-ref",
+			"--symbolic-full-name",
+			"@{upstream}"
+		]).map((output) => {
+			const upstream = output.trim();
+			const slashIndex = upstream.indexOf("/");
+			if (slashIndex > 0) return upstream.substring(0, slashIndex);
+			return null;
+		}).orElse(() => FireflyOkAsync(null));
+	}
+	/**
+	* Lists all configured remotes.
+	* @returns Array of remote names.
+	*/
+	listRemotes() {
+		return this.git(["remote"]).map((output) => output.split("\n").map((remote) => remote.trim()).filter((remote) => remote.length > 0));
+	}
+	inferRepositoryUrl() {
+		return this.getUpstreamRemote().andThen((upstreamRemote) => {
+			if (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();
+		});
+	}
+	/**
+	* Tries to get the repository URL from 'origin' or the first available remote.
+	*/
+	tryOriginOrFirstRemote() {
+		return this.getRemoteUrl("origin").map((url) => {
+			logger.verbose("DefaultGitService: Inferring repository URL from origin remote");
+			return url;
+		}).orElse(() => {
+			return this.listRemotes().andThen((remotes) => {
+				if (remotes.length === 0) {
+					logger.verbose("DefaultGitService: No remotes configured, cannot infer repository URL");
+					return FireflyOkAsync(null);
+				}
+				const firstRemote = remotes[0];
+				logger.verbose(`DefaultGitService: Inferring repository URL from first remote: ${firstRemote}`);
+				return this.getRemoteUrl(firstRemote).map((url) => url).orElse(() => FireflyOkAsync(null));
+			});
+		});
+	}
 };
 /**
 * Creates a git service instance.

package/dist/index.d.ts

@@ -11,6 +11,7 @@ declare const FireflyConfigSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     scope: z.ZodOptional<z.ZodString>;
     base: z.ZodDefault<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
     changelogPath: z.ZodDefault<z.ZodString>;
     bumpStrategy: z.ZodDefault<z.ZodUnion<[z.ZodEnum<{
       auto: "auto";

package/dist/main.js

@@ -71,7 +71,7 @@ const logger = createConsola({
 
 //#endregion
 //#region package.json
-var version = "4.0.0-alpha.8";
+var version = "4.0.0-dev.25c80f6";
 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-CASpr1JR.js");
+	const { createFireflyCLI } = await import("./program-DcCz3-Sc.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-DACeZzRg.js}

@@ -1,3 +1,4 @@
+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 { Result } from "neverthrow";
@@ -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-CASpr1JR.js → program-DcCz3-Sc.js}

@@ -1,6 +1,6 @@
 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 { i as zipAsync, n as wrapPromise, r as zip3Async, t as ensureNotAsync } from "./result.utilities-oXWCXEvw.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 { LogLevels } from "consola";
 import { colors } from "consola/utils";
@@ -1091,11 +1091,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
@@ -1152,17 +1177,28 @@ function extractPreReleaseId(version) {
 }
 /**
 * Hydrates the repository field from git remote URL.
+*
+* Behavior:
+* - If not inside a git repository, resolves to undefined.
+* - If inside a repository, detect the repository URL
+*   using a fall-through strategy (upstream remote → origin → first remote).
+* - Parses the URL and returns "owner/repo" when possible.
 */
 function hydrateRepository(ctx) {
-	return ctx.services.git.isInsideRepository().andThen((isRepo) => {
-		if (!isRepo) return FireflyOkAsync(void 0);
-		return ctx.services.git.getRemoteUrl().map((url) => {
-			const parsed = parseGitRemoteUrl(url);
-			if (parsed) return `${parsed.owner}/${parsed.repo}`;
-			return null;
-		}).orElse(() => FireflyOkAsync(null)).map((val) => val ?? void 0).andTee((repository) => logger.verbose(`PrepareReleaseConfigTask: Prepared repository: ${repository}`));
-	});
+	return ctx.services.git.inferRepositoryUrl().map((url) => {
+		if (!url) return null;
+		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}`));
 }
+/**
+* Hydrates name, scope, and preReleaseId from package.json.
+*
+* Behavior:
+* - If package.json does not exist, returns all values as undefined.
+* - If it exists, reads package.json and returns parsed results for name, scope and preReleaseId.
+*/
 function hydrateFromPackageJson(ctx) {
 	return ctx.services.fs.exists("package.json").andThen((exists) => {
 		if (!exists) return FireflyOkAsync({
@@ -1179,6 +1215,14 @@ function hydrateFromPackageJson(ctx) {
 		}));
 	});
 }
+/**
+* Hydrates the `name` field from package.json when not provided in config.
+*
+* Cases:
+* 1. If name is undefined and package.json has no name, returns a validation error.
+* 2. If name is undefined and package.json has a name, extracts the name (stripping scope) and returns it.
+* 3. Otherwise uses provided name.
+*/
 function hydrateNameFromPackageJson(ctx, packageJson) {
 	if (ctx.config.name === void 0 && !packageJson.name) return validationErrAsync({ message: "Could not find a valid name in package.json" });
 	if (ctx.config.name === void 0 && packageJson.name) {
@@ -1189,6 +1233,14 @@ function hydrateNameFromPackageJson(ctx, packageJson) {
 	logger.verbose(`PrepareReleaseConfigTask: Using provided name: "${ctx.config.name}" as it is explicitly set`);
 	return FireflyOkAsync(ctx.config.name);
 }
+/**
+* Hydrates the `scope` field from package.json when not provided in config.
+*
+* Cases:
+* 1. If scope is explicitly provided (key exists and value is not undefined), it is used.
+* 2. If not provided, but package.json has a scoped `name` (e.g., "@scope/name"), the scope will be extracted and returned.
+* 3. Otherwise returns undefined.
+*/
 function hydrateScopeFromPackageJson(ctx, packageJson) {
 	if (Object.hasOwn(ctx.config, "scope") && ctx.config.scope !== void 0) {
 		logger.verbose(`PrepareReleaseConfigTask: Using provided scope: "${ctx.config.scope}" as it is explicitly set`);
@@ -1204,6 +1256,14 @@ function hydrateScopeFromPackageJson(ctx, packageJson) {
 	logger.verbose("PrepareReleaseConfigTask: No scope to prepare from package.json");
 	return FireflyOkAsync(void 0);
 }
+/**
+* Hydrates the `preReleaseId` field from `package.json.version` when not provided.
+*
+* Cases:
+* 1. If preReleaseId is explicitly provided and not an empty string, it is used.
+* 2. If not provided, and `package.json.version` contains a prerelease segment, the prerelease identifier will be extracted and returned.
+* 3. Otherwise the function defaults to "alpha".
+*/
 function hydratePreReleaseIdFromPackageJson(ctx, packageJson) {
 	if (ctx.config.preReleaseId !== void 0 && ctx.config.preReleaseId.trim() !== "") {
 		logger.verbose(`PrepareReleaseConfigTask: Using provided preReleaseId: "${ctx.config.preReleaseId}" as it is explicitly set`);
@@ -1222,6 +1282,29 @@ function hydratePreReleaseIdFromPackageJson(ctx, packageJson) {
 	return FireflyOkAsync("alpha");
 }
 /**
+* Hydrates branch setting from git.
+*
+* Behavior:
+* - If not inside a git repository, resolves to undefined.
+* - If a branch is explicitly provided in the config, validates it against the
+*   current git branch and returns it (otherwise returns a validation error).
+* - If no branch is provided in the config, uses current git branch.
+*/
+function hydrateBranch(ctx) {
+	return ctx.services.git.isInsideRepository().andThen((isRepo) => {
+		if (!isRepo) return FireflyOkAsync(void 0);
+		return ctx.services.git.getCurrentBranch().andThen((currentBranch) => {
+			if (Object.hasOwn(ctx.config, "branch") && ctx.config.branch !== void 0 && ctx.config.branch.trim() !== "") {
+				if (ctx.config.branch !== currentBranch) return validationErrAsync({ message: `Configured branch "${ctx.config.branch}" does not match current git branch "${currentBranch}"` });
+				logger.verbose(`PrepareReleaseConfigTask: Using provided branch: "${ctx.config.branch}" as it is explicitly set`);
+				return FireflyOkAsync(ctx.config.branch);
+			}
+			logger.verbose(`PrepareReleaseConfigTask: Prepared branch from git: ${currentBranch}`);
+			return FireflyOkAsync(currentBranch);
+		});
+	});
+}
+/**
 * Creates the Prepare Release Config Task.
 *
 * This task determines and hydrates configuration settings, by inferring values from the environment.
@@ -1230,15 +1313,17 @@ function hydratePreReleaseIdFromPackageJson(ctx, packageJson) {
 * 1. Detects repository owner/repo from git remote URL
 * 2. Extracts name and scope from package.json
 * 3. Extracts preReleaseId from package.json version
+* 4. Detects current git branch if not provided
 */
 function createPrepareReleaseConfigTask() {
 	return TaskBuilder.create("prepare-release-config").description("Hydrate and prepare the release configuration").execute((ctx) => {
 		const hydrated = {};
-		return zipAsync(hydrateRepository(ctx), hydrateFromPackageJson(ctx)).map(([repository, pkgData]) => {
+		return zip3Async(hydrateRepository(ctx), hydrateFromPackageJson(ctx), hydrateBranch(ctx)).map(([repository, pkgData, branch]) => {
 			if (repository) hydrated.repository = repository;
 			if (pkgData.name) hydrated.name = pkgData.name;
 			if (pkgData.scope) hydrated.scope = pkgData.scope;
 			if (pkgData.preReleaseId) hydrated.preReleaseId = pkgData.preReleaseId;
+			if (branch) hydrated.branch = branch;
 			logger.verbose(`PrepareReleaseConfigTask: Hydrated config: ${JSON.stringify(hydrated)}`);
 			return ctx.fork("hydratedConfig", hydrated);
 		});
@@ -1454,6 +1539,7 @@ const ReleaseConfigSchema = z$1.object({
 	name: z$1.string().optional().describe("Unscoped project name. Auto-detected from package.json."),
 	scope: z$1.string().optional().describe("Org/user scope without '@'. Auto-detected from package.json."),
 	base: z$1.string().default("").describe("Relative path from repository root to project root."),
+	branch: z$1.string().optional().describe("Git branch to release from."),
 	changelogPath: z$1.string().default("CHANGELOG.md").describe("Changelog file path, relative to project root."),
 	bumpStrategy: BumpStrategySchema.describe("\"auto\" (from commits) or \"manual\" (user-specified)."),
 	releaseType: ReleaseTypeSchema.optional().describe("The release type to bump."),
@@ -1525,19 +1611,19 @@ function defineService(definition) {
 */
 const SERVICE_DEFINITIONS = {
 	fs: defineService({ factory: async ({ basePath }) => {
-		const { createFileSystemService } = await import("./filesystem.service-B_dgIoTJ.js");
+		const { createFileSystemService } = await import("./filesystem.service-9VHML130.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-DACeZzRg.js");
 			return createPackageJsonService(fs);
 		}
 	}),
 	git: defineService({ factory: async ({ basePath }) => {
-		const { createGitService } = await import("./git.service-C5zcZ5BB.js");
+		const { createGitService } = await import("./git.service-CACrfCW8.js");
 		return createGitService(basePath);
 	} })
 };
@@ -2178,7 +2264,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.utilities-oXWCXEvw.js → result.utilities-DC5shlhT.js}

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fireflyy",
-  "version": "4.0.0-alpha.8",
+  "version": "4.0.0-dev.25c80f6",
   "description": " CLI orchestrator for automatic semantic versioning, changelog generation, and creating releases. Built for my own use cases.",
   "type": "module",
   "license": "MIT",
@@ -31,8 +31,8 @@
     }
   },
   "bin": {
-    "firefly": "./dist/main.js",
-    "ff": "./dist/main.js"
+    "firefly": "dist/main.js",
+    "ff": "dist/main.js"
   },
   "publishConfig": {
     "access": "public",
@@ -62,12 +62,12 @@
     "zod": "^4.1.13"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.3.7",
+    "@biomejs/biome": "2.3.8",
     "@types/bun": "^1.3.3",
     "@types/semver": "^7.7.1",
-    "tsdown": "^0.17.0-beta.1",
+    "tsdown": "^0.17.0-beta.5",
     "typescript": "^5.9.3",
-    "ultracite": "6.3.7"
+    "ultracite": "6.3.8"
   },
   "keywords": [
     "cli",