fireflyy 4.0.0-alpha.8 → 4.0.0-dev.3098d1f

package/dist/{index.js → config.js}

@@ -6,17 +6,6 @@
 *
 * @param options - The configuration options
 * @returns The same options (identity function for type inference)
-*
-* @example
-* ```ts
-* export default defineConfig({
-*     verbose: true,
-*     release: {
-*         bumpStrategy: "conventional",
-*         releaseType: "github",
-*     },
-* });
-* ```
 */
 function defineConfig(options) {
 	return options;

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

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

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

@@ -1,6 +1,7 @@
-import { c as notFoundErrAsync } from "./result.constructors-C9M1MP3_.js";
-import { n as wrapPromise } from "./result.utilities-oXWCXEvw.js";
-import { t as withDryRun } from "./dry-run-BfYCtldz.js";
+import { l as notFoundErrAsync } from "./result.constructors-D9jmQ0uj.js";
+import { n as wrapPromise } from "./result.utilities-DiG1ae54.js";
+import { t as logger } from "./logging-BuIkRrn1.js";
+import { t as withDryRun } from "./dry-run-BPDFHMIs.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-B3PC7qIe.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 logger } from "./logging-BuIkRrn1.js";
+import { t as withDryRun } from "./dry-run-BPDFHMIs.js";
 import { ResultAsync } from "neverthrow";
 import { z } from "zod";
 
@@ -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/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-alpha.8";
+var version = "4.0.0-dev.3098d1f";
 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-CASpr1JR.js");
-	createFireflyCLI().parseAsync(process.argv).catch((error) => {
-		logger.error("Fatal error:", error);
-		process.exit(1);
-	});
+	const { createFireflyCLI } = await import("./program-DSsTcwvN.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-QN7SzRTt.js → package-json.service-d4pVcOFd.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 { d as validationErr, f as validationErrAsync, i as FireflyOkAsync, v as toFireflyError } from "./result.constructors-D9jmQ0uj.js";
+import { t as logger } from "./logging-BuIkRrn1.js";
+import { n as parseSchema } from "./schema.utilities-Y2MdlRMu.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.