fireflyy 4.0.0-dev.4721ae4 → 4.0.0-dev.644fea9

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

@@ -1,3 +1,4 @@
+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";
@@ -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-DarjfyXF.js → git.service-CACrfCW8.js}

@@ -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.644fea9";
 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-CHc5t2Xm.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-Cw3A_k7R.js → program-CHc5t2Xm.js}

@@ -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
@@ -1586,19 +1611,19 @@ 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-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-DarjfyXF.js");
+		const { createGitService } = await import("./git.service-CACrfCW8.js");
 		return createGitService(basePath);
 	} })
 };

package/package.json

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