fireflyy 4.0.0-dev.6b1dcb0 → 4.0.0-dev.a10ed44

package/assets/firefly.schema.json

@@ -145,17 +145,14 @@
         },
         "releaseLatest": {
           "description": "Mark as latest release.",
-          "default": true,
           "type": "boolean"
         },
         "releasePreRelease": {
           "description": "Mark as pre-release.",
-          "default": false,
           "type": "boolean"
         },
         "releaseDraft": {
           "description": "Release as draft version.",
-          "default": false,
           "type": "boolean"
         }
       }

package/dist/{commit-analysis.service-BNlHyyhC.js → commit-analysis.service-Ba6hLgsr.js}

@@ -1,6 +1,6 @@
-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 { TRANSITION_KEYWORDS } from "./version-strategy.service-Ds4mvlDC.js";
+import { h as invalidError, i as FireflyOkAsync, r as FireflyOk, t as FireflyErr } from "./result.constructors-BMtOWD2-.js";
+import { t as logger } from "./logging-BuIkRrn1.js";
+import { TRANSITION_KEYWORDS } from "./version-strategy.service-CmfeZLYC.js";
 
 //#region src/domain/commits/commit-types.ts
 /**

package/dist/config.d.ts

@@ -1,7 +1,65 @@
 import z from "zod";
 
-//#region src/cli/config/config.schema.d.ts
+//#region src/commands/release/release.config.d.ts
 
+declare const ReleaseConfigSchema: 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";
+    manual: "manual";
+  }>, z.ZodLiteral<"">]>>;
+  releaseType: z.ZodOptional<z.ZodEnum<{
+    major: "major";
+    minor: "minor";
+    patch: "patch";
+    prerelease: "prerelease";
+    premajor: "premajor";
+    preminor: "preminor";
+    prepatch: "prepatch";
+    graduate: "graduate";
+  }>>;
+  preReleaseId: z.ZodOptional<z.ZodString>;
+  preReleaseBase: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"0">, z.ZodLiteral<"1">]>>;
+  releaseNotes: z.ZodDefault<z.ZodString>;
+  commitMessage: z.ZodDefault<z.ZodString>;
+  tagName: z.ZodDefault<z.ZodString>;
+  skipBump: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+  skipChangelog: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+  skipPush: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+  skipGitHubRelease: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+  skipGit: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+  skipPreflightCheck: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+  releaseTitle: z.ZodDefault<z.ZodString>;
+  releaseLatest: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+  releasePreRelease: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+  releaseDraft: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+}, z.core.$strip>;
+type BaseRelease = z.infer<typeof ReleaseConfigSchema>;
+type ReleaseFlagKeys = "releaseLatest" | "releasePreRelease" | "releaseDraft";
+type ExclusiveReleaseFlags = {
+  releaseLatest: true;
+  releasePreRelease?: false | undefined;
+  releaseDraft?: false | undefined;
+} | {
+  releasePreRelease: true;
+  releaseLatest?: false | undefined;
+  releaseDraft?: false | undefined;
+} | {
+  releaseDraft: true;
+  releaseLatest?: false | undefined;
+  releasePreRelease?: false | undefined;
+} | {
+  releaseLatest?: false | undefined;
+  releasePreRelease?: false | undefined;
+  releaseDraft?: false | undefined;
+};
+type ReleaseConfig = Omit<BaseRelease, ReleaseFlagKeys> & ExclusiveReleaseFlags;
+//#endregion
+//#region src/cli/config/config.schema.d.ts
 /**
  * Complete Firefly configuration schema.
  * Combines global options with command-specific configuration sections.
@@ -39,9 +97,9 @@ declare const FireflyConfigSchema: z.ZodObject<{
     skipGit: z.ZodOptional<z.ZodDefault<z.ZodCoercedBoolean<unknown>>>;
     skipPreflightCheck: z.ZodOptional<z.ZodDefault<z.ZodCoercedBoolean<unknown>>>;
     releaseTitle: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-    releaseLatest: z.ZodOptional<z.ZodDefault<z.ZodCoercedBoolean<unknown>>>;
-    releasePreRelease: z.ZodOptional<z.ZodDefault<z.ZodCoercedBoolean<unknown>>>;
-    releaseDraft: z.ZodOptional<z.ZodDefault<z.ZodCoercedBoolean<unknown>>>;
+    releaseLatest: z.ZodOptional<z.ZodOptional<z.ZodCoercedBoolean<unknown>>>;
+    releasePreRelease: z.ZodOptional<z.ZodOptional<z.ZodCoercedBoolean<unknown>>>;
+    releaseDraft: z.ZodOptional<z.ZodOptional<z.ZodCoercedBoolean<unknown>>>;
   }, z.core.$strip>>;
   cwd: z.ZodOptional<z.ZodOptional<z.ZodString>>;
   dryRun: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
@@ -52,7 +110,9 @@ declare const FireflyConfigSchema: z.ZodObject<{
  * TypeScript type for Firefly configuration.
  * Use this type when you need to reference the configuration shape without runtime validation.
  */
-type FireflyConfig = z.infer<typeof FireflyConfigSchema>;
+type FireflyConfig = z.infer<typeof FireflyConfigSchema> & {
+  release?: Partial<Omit<ReleaseConfig, ReleaseFlagKeys>> & ExclusiveReleaseFlags;
+};
 //#endregion
 //#region src/config/index.d.ts
 /**

package/dist/{dry-run-BeuzUufT.js → dry-run-Cdg-c0EP.js}

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

package/dist/{filesystem.service-Bl5h9T_0.js → filesystem.service-B8qg87n-.js}

@@ -1,7 +1,7 @@
-import { t as logger } from "./main.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-BeuzUufT.js";
+import { c as notFoundErrAsync } from "./result.constructors-BMtOWD2-.js";
+import { n as wrapPromise } from "./result.utilities-BTVU-GsT.js";
+import { t as logger } from "./logging-BuIkRrn1.js";
+import { t as withDryRun } from "./dry-run-Cdg-c0EP.js";
 
 //#region src/services/implementations/filesystem.service.ts
 /**

package/dist/{git.service-C0qRXy1s.js → git.service-BBqDH7qx.js}

@@ -1,6 +1,6 @@
-import { t as logger } from "./main.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 { i as FireflyOkAsync, m as failedError, o as failedErrAsync } from "./result.constructors-BMtOWD2-.js";
+import { t as logger } from "./logging-BuIkRrn1.js";
+import { t as withDryRun } from "./dry-run-Cdg-c0EP.js";
 import { ResultAsync } from "neverthrow";
 import { z } from "zod";
 

package/dist/logging-BuIkRrn1.js

@@ -0,0 +1,20 @@
+import { createConsola } from "consola";
+import { colors } from "consola/utils";
+
+//#region src/infrastructure/logging/index.ts
+const opts = {
+	date: false,
+	compact: true,
+	columns: 0
+};
+const _logger = createConsola({ formatOptions: opts });
+const logger = createConsola({
+	formatOptions: opts,
+	reporters: [{ log(logObj) {
+		if (logObj.type === "verbose") console.log(colors.gray(logObj.args.join(" ")));
+		else _logger.log(logObj);
+	} }]
+});
+
+//#endregion
+export { logger as t };

package/dist/main.js

@@ -1,7 +1,4 @@
 #!/usr/bin/env bun
-import { createConsola } from "consola";
-import { colors } from "consola/utils";
-
 //#region src/core/environment/runtime-env.ts
 /**
 * These are set during CLI initialization in main.ts and provide
@@ -53,25 +50,9 @@ var RuntimeEnv = class {
 	}
 };
 
-//#endregion
-//#region src/infrastructure/logging/index.ts
-const opts = {
-	date: false,
-	compact: true,
-	columns: 0
-};
-const _logger = createConsola({ formatOptions: opts });
-const logger = createConsola({
-	formatOptions: opts,
-	reporters: [{ log(logObj) {
-		if (logObj.type === "verbose") console.log(colors.gray(logObj.args.join(" ")));
-		else _logger.log(logObj);
-	} }]
-});
-
 //#endregion
 //#region package.json
-var version = "4.0.0-dev.6b1dcb0";
+var version = "4.0.0-dev.a10ed44";
 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,13 +80,10 @@ async function main() {
 		description,
 		gitCliffVersion: dependencies["git-cliff"]?.replace("^", "") || "unknown"
 	});
-	const { createFireflyCLI } = await import("./program-BVc78BFb.js");
-	createFireflyCLI().parseAsync(process.argv).catch((error) => {
-		logger.error("Fatal error:", error);
-		process.exit(1);
-	});
+	const { createFireflyCLI } = await import("./program-Dqo9sQjU.js");
+	createFireflyCLI().parseAsync(process.argv).catch(() => process.exit(1));
 }
 main();
 
 //#endregion
-export { RuntimeEnv as n, logger as t };
+export { RuntimeEnv as t };

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

@@ -1,6 +1,6 @@
-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 { _ as toFireflyError, d as validationErrAsync, i as FireflyOkAsync, u as validationErr } from "./result.constructors-BMtOWD2-.js";
+import { t as logger } from "./logging-BuIkRrn1.js";
+import { n as parseSchema } from "./schema.utilities-BxiRR-GI.js";
 import { Result } from "neverthrow";
 import z$1 from "zod";
 

package/dist/{program-BVc78BFb.js → program-Dqo9sQjU.js}

@@ -1,10 +1,11 @@
-import { n as RuntimeEnv, t as logger } from "./main.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 { t as RuntimeEnv } from "./main.js";
+import { a as conflictErrAsync, c as notFoundErrAsync, d as validationErrAsync, f as conflictError, g as notFoundError, i as FireflyOkAsync, l as timeoutErrAsync, m as failedError, n as FireflyErrAsync, o as failedErrAsync, r as FireflyOk, s as invalidErr, t as FireflyErr, u as validationErr, v as validationError, y as wrapErrorMessage } from "./result.constructors-BMtOWD2-.js";
+import { n as wrapPromise, t as ensureNotAsync } from "./result.utilities-BTVU-GsT.js";
+import { t as logger } from "./logging-BuIkRrn1.js";
+import { n as parseSchema, t as formatZodErrors } from "./schema.utilities-BxiRR-GI.js";
+import { Command } from "commander";
 import { LogLevels } from "consola";
 import { colors } from "consola/utils";
-import { Command } from "commander";
 import { loadConfig } from "c12";
 import { Result, ResultAsync, err, ok } from "neverthrow";
 import z$1 from "zod";
@@ -1075,17 +1076,15 @@ 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", {
+	return wrapPromise(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(() => {
+		cancel: "undefined"
+	})).andThen((selected) => {
+		if (!selected || selected === "") return failedErrAsync({ message: "Operation cancelled by user" });
 		if (logger.level === LogLevels.verbose) logger.log("");
-	}).andThen((selected) => {
-		if (!selected || selected === "") return invalidErrAsync({ message: "No version bump strategy selected" });
+		if (logger.level !== LogLevels.verbose) logger.log("");
 		const validationResult = validateStrategy(selected);
 		if (validationResult.isErr()) return FireflyErrAsync(validationResult.error);
 		logger.verbose(`PromptBumpStrategyTask: Selected version bump strategy: '${selected}'`);
@@ -1180,6 +1179,12 @@ const SSH_REMOTE_REGEX = /git@[^:]+:([^/]+)\/([^/.]+)(?:\.git)?/;
 const SCOPED_PACKAGE_REGEX = /^@([^/]+)\/(.+)$/;
 const PRERELEASE_REGEX = /^\d+\.\d+\.\d+-([a-zA-Z]+)/;
 /**
+* Terminologies:
+*
+* Prepared: The value has been determined and set in the context.
+* Using: The value was explicitly provided in the config and is used as-is.
+*/
+/**
 * Parses a git remote URL to extract owner and repository name.
 * Supports both HTTPS and SSH formats.
 *
@@ -1226,46 +1231,6 @@ function extractPreReleaseId(version) {
 	return version.match(PRERELEASE_REGEX)?.[1];
 }
 /**
-* 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.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({
-			name: void 0,
-			scope: void 0,
-			preReleaseId: void 0
-		});
-		return ctx.services.packageJson.read("package.json").andThen((pkg) => zip3Async(hydrateNameFromPackageJson(ctx, pkg), hydrateScopeFromPackageJson(ctx, pkg), hydratePreReleaseIdFromPackageJson(ctx, pkg)).map(([name, scope, preReleaseId]) => {
-			const result = {};
-			if (name) result.name = name;
-			if (scope) result.scope = scope;
-			if (preReleaseId) result.preReleaseId = preReleaseId;
-			return result;
-		}));
-	});
-}
-/**
 * Hydrates the `name` field from package.json when not provided in config.
 *
 * Cases:
@@ -1332,6 +1297,46 @@ function hydratePreReleaseIdFromPackageJson(ctx, packageJson) {
 	return FireflyOkAsync("alpha");
 }
 /**
+* 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({
+			name: void 0,
+			scope: void 0,
+			preReleaseId: void 0
+		});
+		return ctx.services.packageJson.read("package.json").andThen((pkg) => hydrateNameFromPackageJson(ctx, pkg).andThen((name) => hydrateScopeFromPackageJson(ctx, pkg).andThen((scope) => hydratePreReleaseIdFromPackageJson(ctx, pkg).map((preReleaseId) => {
+			const result = {};
+			if (name) result.name = name;
+			if (scope) result.scope = scope;
+			if (preReleaseId) result.preReleaseId = preReleaseId;
+			return result;
+		}))));
+	});
+}
+/**
+* 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.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 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 branch setting from git.
 *
 * Behavior:
@@ -1355,6 +1360,71 @@ function hydrateBranch(ctx) {
 	});
 }
 /**
+* Hydrates repository and branch information from git.
+*
+* Behavior:
+* - If not inside a git repository, resolves both values to undefined.
+* - Otherwise it composes `hydrateRepository` and `hydrateBranch` and returns both values.
+*/
+function hydrateFromGit(ctx) {
+	return ctx.services.git.isInsideRepository().andThen((isRepo) => {
+		if (!isRepo) return FireflyOkAsync({
+			repository: void 0,
+			branch: void 0
+		});
+		return hydrateRepository(ctx).andThen((repository) => hydrateBranch(ctx).map((branch) => {
+			const result = {};
+			if (repository) result.repository = repository;
+			if (branch) result.branch = branch;
+			return result;
+		}));
+	});
+}
+/**
+* Hydrates release flags (releaseLatest, releasePreRelease, releaseDraft).
+*
+* Behavior:
+* - If exactly one flag is explicitly set to true, use that and set others to false.
+* - If no flags are explicitly set, default to releaseLatest = true, others = false.
+* - Validation of exclusivity is handled by the schema, so we only need to determine defaults.
+*/
+function hydrateReleaseFlags(ctx) {
+	const { releaseLatest, releasePreRelease, releaseDraft } = ctx.config;
+	const latestExplicit = releaseLatest === true;
+	const preReleaseExplicit = releasePreRelease === true;
+	const draftExplicit = releaseDraft === true;
+	if (preReleaseExplicit) {
+		logger.verbose(`PrepareReleaseConfigTask: Using "releasePreRelease" as it is explicitly set`);
+		return FireflyOkAsync({
+			releaseLatest: false,
+			releasePreRelease: true,
+			releaseDraft: false
+		});
+	}
+	if (draftExplicit) {
+		logger.verbose(`PrepareReleaseConfigTask: Using "releaseDraft" as it is explicitly set`);
+		return FireflyOkAsync({
+			releaseLatest: false,
+			releasePreRelease: false,
+			releaseDraft: true
+		});
+	}
+	if (latestExplicit) {
+		logger.verbose(`PrepareReleaseConfigTask: Using "releaseLatest" as it is explicitly set`);
+		return FireflyOkAsync({
+			releaseLatest: true,
+			releasePreRelease: false,
+			releaseDraft: false
+		});
+	}
+	logger.verbose("PrepareReleaseConfigTask: Prepared releaseLatest as default since no flag was explicitly set");
+	return FireflyOkAsync({
+		releaseLatest: true,
+		releasePreRelease: false,
+		releaseDraft: false
+	});
+}
+/**
 * Creates the Prepare Release Config Task.
 *
 * This task determines and hydrates configuration settings, by inferring values from the environment.
@@ -1364,17 +1434,24 @@ function hydrateBranch(ctx) {
 * 2. Extracts name and scope from package.json
 * 3. Extracts preReleaseId from package.json version
 * 4. Detects current git branch if not provided
+* 5. Determines release flags (latest, preRelease, draft) with proper defaults
 */
 function createPrepareReleaseConfigTask() {
 	return TaskBuilder.create("prepare-release-config").description("Hydrate and prepare the release configuration").execute((ctx) => {
 		const hydrated = {};
-		return zip3Async(hydrateRepository(ctx), hydrateFromPackageJson(ctx), hydrateBranch(ctx)).map(([repository, pkgData, branch]) => {
-			if (repository) hydrated.repository = repository;
+		return hydrateFromGit(ctx).andThen((gitData) => {
+			if (gitData.repository) hydrated.repository = gitData.repository;
+			if (gitData.branch) hydrated.branch = gitData.branch;
+			return hydrateFromPackageJson(ctx);
+		}).andThen((pkgData) => {
 			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 hydrateReleaseFlags(ctx);
+		}).map((releaseFlags) => {
+			hydrated.releaseLatest = releaseFlags.releaseLatest;
+			hydrated.releasePreRelease = releaseFlags.releasePreRelease;
+			hydrated.releaseDraft = releaseFlags.releaseDraft;
 			return ctx.fork("hydratedConfig", hydrated);
 		});
 	}).build();
@@ -1542,7 +1619,7 @@ function validateReleaseFlagExclusivity(ctx) {
 		"releasePreRelease",
 		"releaseDraft"
 	];
-	if (flagNames.filter((k) => ctx.value[k]).length > 1) ctx.issues.push({
+	if (flagNames.filter((k) => ctx.value[k] === true).length > 1) ctx.issues.push({
 		code: "custom",
 		message: `Only one of ${flagNames.join(", ")} can be set to true.`,
 		input: ctx.value,
@@ -1605,9 +1682,9 @@ const ReleaseConfigSchema = z$1.object({
 	skipGit: z$1.coerce.boolean().default(false).describe("Skip all git-related steps."),
 	skipPreflightCheck: z$1.coerce.boolean().default(false).describe("Skip preflight checks."),
 	releaseTitle: z$1.string().default(RELEASE_TITLE_TEMPLATE).describe("GitHub release title with placeholders."),
-	releaseLatest: z$1.coerce.boolean().default(true).describe("Mark as latest release."),
-	releasePreRelease: z$1.coerce.boolean().default(false).describe("Mark as pre-release."),
-	releaseDraft: z$1.coerce.boolean().default(false).describe("Release as draft version.")
+	releaseLatest: z$1.coerce.boolean().optional().describe("Mark as latest release."),
+	releasePreRelease: z$1.coerce.boolean().optional().describe("Mark as pre-release."),
+	releaseDraft: z$1.coerce.boolean().optional().describe("Release as draft version.")
 }).check((ctx) => {
 	validateReleaseFlagExclusivity(ctx);
 	validateSkipGitRedundancy(ctx);
@@ -1661,30 +1738,30 @@ function defineService(definition) {
 */
 const SERVICE_DEFINITIONS = {
 	fs: defineService({ factory: async ({ basePath }) => {
-		const { createFileSystemService } = await import("./filesystem.service-Bl5h9T_0.js");
+		const { createFileSystemService } = await import("./filesystem.service-B8qg87n-.js");
 		return createFileSystemService(basePath);
 	} }),
 	packageJson: defineService({
 		dependencies: ["fs"],
 		factory: async ({ getService }) => {
 			const fs = await getService("fs");
-			const { createPackageJsonService } = await import("./package-json.service-B6ultpL4.js");
+			const { createPackageJsonService } = await import("./package-json.service-CHmtIoQQ.js");
 			return createPackageJsonService(fs);
 		}
 	}),
 	git: defineService({ factory: async ({ basePath }) => {
-		const { createGitService } = await import("./git.service-C0qRXy1s.js");
+		const { createGitService } = await import("./git.service-BBqDH7qx.js");
 		return createGitService(basePath);
 	} }),
 	versionBumper: defineService({ factory: async () => {
-		const { createVersionBumperService } = await import("./version-bumper.service-BYsIFCpv.js");
+		const { createVersionBumperService } = await import("./version-bumper.service-DMYR0npB.js");
 		return createVersionBumperService();
 	} }),
 	versionStrategy: defineService({
 		dependencies: ["versionBumper"],
 		factory: async ({ getService }) => {
 			const versionBumper = await getService("versionBumper");
-			const { createVersionStrategyService } = await import("./version-strategy.service-Ds4mvlDC.js");
+			const { createVersionStrategyService } = await import("./version-strategy.service-CmfeZLYC.js");
 			return createVersionStrategyService(versionBumper);
 		}
 	}),
@@ -1692,7 +1769,7 @@ const SERVICE_DEFINITIONS = {
 		dependencies: ["git"],
 		factory: async ({ getService }) => {
 			const git = await getService("git");
-			const { createCommitAnalysisService } = await import("./commit-analysis.service-BNlHyyhC.js");
+			const { createCommitAnalysisService } = await import("./commit-analysis.service-Ba6hLgsr.js");
 			return createCommitAnalysisService(git);
 		}
 	})
@@ -2366,6 +2443,8 @@ var WorkflowExecutor = class {
 	handleExecutionFailure(args) {
 		const { error, startTime, executedTaskIds, skippedTaskIds, initialContext } = args;
 		const endTime = /* @__PURE__ */ new Date();
+		if (DebugFlags.showRawError) logger.error(error);
+		else logger.error(error.message);
 		if (this.options.enableRollback && this.executedTasks.length > 0) {
 			logger.verbose(`WorkflowExecutor: Attempting rollback of ${this.executedTasks.length} tasks`);
 			return this.rollback(initialContext).andThen((rollbackSuccess) => {
@@ -2441,9 +2520,6 @@ var WorkflowExecutor = class {
 			executionLists.executedTaskIds.push(currentTask.meta.id);
 			this.executedTasks.push(currentTask);
 			return this.executeTasksSequentially(remainingTasks, updatedContext, executionLists.executedTaskIds, executionLists.skippedTaskIds);
-		}).mapErr((error) => {
-			logger.error(error.message);
-			return error;
 		});
 	}
 	rollback(context) {

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

@@ -253,13 +253,9 @@ 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 { 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 };
+export { toFireflyError as _, conflictErrAsync as a, notFoundErrAsync as c, validationErrAsync as d, conflictError as f, notFoundError as g, invalidError 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, validationError as v, wrapErrorMessage as y };

package/dist/{result.utilities-CdBL5noX.js → result.utilities-BTVU-GsT.js}

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

package/dist/{schema.utilities-BOJqWEey.js → schema.utilities-BxiRR-GI.js}

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

package/dist/{version-bumper.service-BYsIFCpv.js → version-bumper.service-DMYR0npB.js}

@@ -1,4 +1,4 @@
-import { r as FireflyOk, s as invalidErr, t as FireflyErr } from "./result.constructors-D9jmQ0uj.js";
+import { r as FireflyOk, s as invalidErr, t as FireflyErr } from "./result.constructors-BMtOWD2-.js";
 import semver from "semver";
 
 //#region src/domain/semver/version.ts

package/dist/{version-strategy.service-Ds4mvlDC.js → version-strategy.service-CmfeZLYC.js}

@@ -1,5 +1,5 @@
-import { t as logger } from "./main.js";
-import { g as invalidError, r as FireflyOk, t as FireflyErr } from "./result.constructors-D9jmQ0uj.js";
+import { h as invalidError, r as FireflyOk, t as FireflyErr } from "./result.constructors-BMtOWD2-.js";
+import { t as logger } from "./logging-BuIkRrn1.js";
 import { Result } from "neverthrow";
 
 //#region src/services/implementations/version-strategy.service.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fireflyy",
-  "version": "4.0.0-dev.6b1dcb0",
+  "version": "4.0.0-dev.a10ed44",
   "description": " CLI orchestrator for automatic semantic versioning, changelog generation, and creating releases. Built for my own use cases.",
   "type": "module",
   "license": "MIT",
@@ -67,7 +67,7 @@
     "@types/semver": "^7.7.1",
     "tsdown": "^0.17.0-beta.6",
     "typescript": "^5.9.3",
-    "ultracite": "6.3.8"
+    "ultracite": "6.3.9"
   },
   "keywords": [
     "cli",