fireflyy 4.0.0-dev.644fea9 → 4.0.0-dev.988c93c

package/assets/firefly.schema.json

@@ -1,5 +1,6 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
+  "description": "Firefly CLI configuration.",
   "type": "object",
   "properties": {
     "cwd": {
@@ -144,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-Ba6hLgsr.js

@@ -0,0 +1,503 @@
+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
+/**
+* Default configuration for conventional commit type analysis.
+*/
+const DEFAULT_COMMIT_TYPE_CONFIG = {
+	major: ["revert"],
+	minor: ["feat", "feature"],
+	patch: [
+		"fix",
+		"perf",
+		"refactor",
+		"style",
+		"test",
+		"build",
+		"ci",
+		"chore",
+		"docs",
+		"security"
+	],
+	scopeRules: {
+		deps: "patch",
+		dependencies: "patch",
+		security: "patch",
+		api: "minor",
+		breaking: "major",
+		"breaking-change": "major"
+	}
+};
+
+//#endregion
+//#region src/services/implementations/commit-analysis.service.ts
+const COMMIT_MESSAGE_PATTERNS = {
+	BREAKING: /^(\w*)(?:\((.*)\))?!: (.*)$/,
+	CONVENTIONAL: /^(\w*)(?:\((.*)\))?: (.*)$/,
+	REVERT: /^Revert "(.+)"\s*\[([a-f0-9]+)\]$/
+};
+const EXTRACTION_PATTERNS = {
+	BREAKING_CHANGE: /BREAKING CHANGE:\s*(.+?)(?=\n\n|\n[A-Z]|$)/gs,
+	MENTION: /@([a-zA-Z0-9_-]+)/g,
+	REFERENCE: /(fixes?|closes?|resolves?)\s+#(\d+)|#(\d+)/gi
+};
+const ANALYSIS_PATTERNS = {
+	BREAKING_HEADER: /^[a-zA-Z]+(?:\([^)]*\))?!:/,
+	SCOPE_HEADER: /^[a-zA-Z]+\(([^)]+)\)[:!]/
+};
+const VERSION_LEVELS = {
+	MAJOR: 0,
+	MINOR: 1,
+	PATCH: 2
+};
+const LEVEL_TO_RELEASE_TYPE = {
+	0: "major",
+	1: "minor",
+	2: "patch"
+};
+var DefaultCommitAnalysisService = class {
+	git;
+	constructor(git) {
+		this.git = git;
+	}
+	analyzeForVersion(options) {
+		logger.verbose("CommitAnalysisService: Starting commit analysis for version recommendation...");
+		const startTime = Date.now();
+		return this.getCommitsSinceLastTag().map((commits) => {
+			if (commits.length === 0) {
+				logger.verbose("CommitAnalysisService: No commits provided, returning patch recommendation.");
+				return this.createDefaultPatchRecommendation();
+			}
+			const config = this.mergeConfiguration(options?.config ?? {});
+			const analysis = this.performDetailedAnalysis(commits, config);
+			const versionLevel = this.determineVersionLevel(analysis);
+			const recommendation = this.buildVersionRecommendation(versionLevel, analysis);
+			const duration = Date.now() - startTime;
+			logger.verbose(`CommitAnalysisService: Analysis completed in ${duration}ms. Recommendation: ${recommendation.releaseType}`);
+			return recommendation;
+		});
+	}
+	createDefaultRecommendation() {
+		return this.createDefaultPatchRecommendation();
+	}
+	/**
+	* Retrieves commits since the last tag without analysis.
+	*
+	* @returns Array of parsed commits
+	*/
+	getCommitsSinceLastTag() {
+		logger.verbose("CommitAnalysisService: Retrieving commits since last tag");
+		return this.git.getLatestTag().andThen((lastTag) => {
+			logger.verbose(`CommitAnalysisService: Last tag is: ${lastTag ?? "none"}`);
+			return this.git.getCommitHashesSince(lastTag).andThen((hashes) => {
+				if (hashes.length === 0) {
+					logger.verbose("CommitAnalysisService: No new commits found since last tag");
+					return FireflyOkAsync([]);
+				}
+				return this.parseCommitHashes(hashes);
+			});
+		});
+	}
+	/**
+	* Extracts commit fields from raw commit details.
+	*
+	* @param rawDetails - The raw commit details string
+	* @returns An object containing extracted commit fields
+	*/
+	extractCommitFields(rawDetails) {
+		const lines = rawDetails.trim().split("\n");
+		const commitData = {};
+		for (const line of lines) {
+			const colonIndex = line.indexOf(":");
+			if (colonIndex === -1) continue;
+			const key = line.substring(0, colonIndex);
+			commitData[key] = line.substring(colonIndex + 1);
+		}
+		return {
+			subject: commitData.subject ?? "",
+			body: commitData.body ?? "",
+			author: commitData.author ?? "",
+			date: commitData.date ?? "",
+			notes: commitData.notes ?? ""
+		};
+	}
+	/**
+	* Analyzes the commit message to extract type, scope, and subject.
+	*
+	* @param subject - The commit subject line
+	* @returns An object with type, scope, and subject
+	*/
+	analyzeCommitMessage(subject) {
+		const breakingMatch = subject.match(COMMIT_MESSAGE_PATTERNS.BREAKING);
+		if (breakingMatch) return {
+			type: breakingMatch[1] ?? null,
+			scope: breakingMatch[2] ?? null,
+			subject: breakingMatch[3] ?? null
+		};
+		const conventionalMatch = subject.match(COMMIT_MESSAGE_PATTERNS.CONVENTIONAL);
+		if (conventionalMatch) return {
+			type: conventionalMatch[1] ?? null,
+			scope: conventionalMatch[2] ?? null,
+			subject: conventionalMatch[3] ?? null
+		};
+		return {
+			type: null,
+			scope: null,
+			subject: subject || null
+		};
+	}
+	/**
+	* Extracts revert information from commit subject.
+	*
+	* @param subject - The commit subject line
+	* @returns An object with revert header and hash, or null if not a revert
+	*/
+	extractRevertInfo(subject) {
+		const revertMatch = subject.match(COMMIT_MESSAGE_PATTERNS.REVERT);
+		if (revertMatch) return {
+			header: revertMatch[1] ?? null,
+			hash: revertMatch[2] ?? null
+		};
+		return null;
+	}
+	/**
+	* Extracts BREAKING CHANGE notes from commit body and notes.
+	*
+	* @param body - The commit body text
+	* @param notes - The commit notes text
+	* @returns An array of CommitNote objects
+	*/
+	extractBreakingChangeNotes(body, notes) {
+		const breakingNotes = [];
+		const fullText = `${body}\n${notes}`;
+		EXTRACTION_PATTERNS.BREAKING_CHANGE.lastIndex = 0;
+		let match = EXTRACTION_PATTERNS.BREAKING_CHANGE.exec(fullText);
+		while (match !== null) {
+			const text = match[1];
+			if (text) breakingNotes.push({
+				title: "BREAKING CHANGE",
+				text: text.trim()
+			});
+			match = EXTRACTION_PATTERNS.BREAKING_CHANGE.exec(fullText);
+		}
+		return breakingNotes;
+	}
+	/**
+	* Extracts @mentions from commit text.
+	*
+	* @param text - The commit text to analyze
+	* @returns An array of mention strings
+	*/
+	extractMentions(text) {
+		const mentions = [];
+		EXTRACTION_PATTERNS.MENTION.lastIndex = 0;
+		let match = EXTRACTION_PATTERNS.MENTION.exec(text);
+		while (match !== null) {
+			const mention = match[1];
+			if (mention) mentions.push(mention);
+			match = EXTRACTION_PATTERNS.MENTION.exec(text);
+		}
+		return mentions;
+	}
+	/**
+	* Extracts issue/PR references from commit text.
+	*
+	* @param text - The commit text to analyze
+	* @returns An array of CommitReference objects
+	*/
+	extractReferences(text) {
+		const references = [];
+		EXTRACTION_PATTERNS.REFERENCE.lastIndex = 0;
+		let match = EXTRACTION_PATTERNS.REFERENCE.exec(text);
+		while (match !== null) {
+			const action = match[1] ?? null;
+			const issue = match[2] ?? match[3];
+			if (issue) references.push({
+				raw: match[0],
+				action: action?.toLowerCase() ?? null,
+				owner: null,
+				repository: null,
+				issue,
+				prefix: "#"
+			});
+			match = EXTRACTION_PATTERNS.REFERENCE.exec(text);
+		}
+		return references;
+	}
+	/**
+	* Parses raw commit details into a Commit object.
+	*
+	* @param rawDetails - The raw commit details string
+	* @param hash - The commit hash
+	* @returns A FireflyResult containing the parsed Commit object
+	*/
+	parseCommitFromRaw(rawDetails, hash) {
+		if (!rawDetails || typeof rawDetails !== "string") return FireflyErr(invalidError({ message: `Invalid commit details for ${hash}` }));
+		const details = this.extractCommitFields(rawDetails);
+		const messageAnalysis = this.analyzeCommitMessage(details.subject);
+		const revertInfo = this.extractRevertInfo(details.subject);
+		const breakingNotes = this.extractBreakingChangeNotes(details.body, details.notes);
+		const mentions = this.extractMentions(details.body);
+		const references = this.extractReferences(details.body);
+		return FireflyOk({
+			hash,
+			date: details.date || null,
+			author: details.author || null,
+			header: details.subject || null,
+			body: details.body || null,
+			footer: null,
+			type: messageAnalysis.type,
+			scope: messageAnalysis.scope,
+			subject: messageAnalysis.subject,
+			merge: null,
+			revert: revertInfo,
+			notes: breakingNotes,
+			mentions,
+			references
+		});
+	}
+	/**
+	* Parses a list of commit hashes into Commit objects.
+	*
+	* @param hashes - The list of commit hashes to parse
+	* @returns A FireflyAsyncResult containing the list of parsed Commit objects
+	*/
+	parseCommitHashes(hashes) {
+		return hashes.reduce((acc, hash) => acc.andThen((commits) => this.git.getCommitDetails(hash).andThen((rawDetails) => {
+			const parsed = this.parseCommitFromRaw(rawDetails, hash);
+			if (parsed.isErr()) {
+				logger.verbose(`CommitAnalysisService: Failed to parse commit ${hash}: ${parsed.error.message}`);
+				return FireflyOkAsync(commits);
+			}
+			return FireflyOkAsync([...commits, parsed.value]);
+		})), FireflyOkAsync([]));
+	}
+	/**
+	* Merges user-provided commit type configuration with defaults.
+	*
+	* @param partial - Partial commit type configuration from user
+	* @returns Complete commit type configuration
+	*/
+	mergeConfiguration(partial) {
+		return {
+			major: [...DEFAULT_COMMIT_TYPE_CONFIG.major, ...partial.major ?? []],
+			minor: [...DEFAULT_COMMIT_TYPE_CONFIG.minor, ...partial.minor ?? []],
+			patch: [...DEFAULT_COMMIT_TYPE_CONFIG.patch, ...partial.patch ?? []],
+			scopeRules: {
+				...DEFAULT_COMMIT_TYPE_CONFIG.scopeRules,
+				...partial.scopeRules
+			}
+		};
+	}
+	/**
+	* Determines if the commit header indicates a breaking change.
+	*
+	* @param commit - The commit to analyze
+	* @returns True if the header indicates a breaking change, false otherwise
+	*/
+	hasBreakingHeader(commit) {
+		if (!commit.header) return false;
+		return ANALYSIS_PATTERNS.BREAKING_HEADER.test(commit.header);
+	}
+	/**
+	* Counts the number of breaking changes in a commit.
+	*
+	* @param commit - The commit to analyze
+	* @returns The number of breaking changes found
+	*/
+	countBreakingChanges(commit) {
+		let breakingCount = 0;
+		breakingCount += commit.notes?.length ?? 0;
+		if (this.hasBreakingHeader(commit)) breakingCount += 1;
+		return breakingCount;
+	}
+	/**
+	* Determines if the commit is a feature commit.
+	*
+	* @param commit - The commit to analyze
+	* @param config - The commit type configuration
+	* @returns True if the commit is a feature commit, false otherwise
+	*/
+	isFeatureCommit(commit, config) {
+		const type = commit.type?.toLowerCase() ?? "";
+		return config.minor.includes(type);
+	}
+	/**
+	* Determines if the commit is a patch-level commit.
+	*
+	* @param commit - The commit to analyze
+	* @param config - The commit type configuration
+	* @returns True if the commit is a patch-level commit, false otherwise
+	*/
+	isPatchCommit(commit, config) {
+		const type = commit.type?.toLowerCase() ?? "";
+		return config.patch.includes(type);
+	}
+	/**
+	* Extracts the scope from a commit.
+	*
+	* @param commit - The commit to extract the scope from
+	* @returns The extracted scope or null if not found
+	*/
+	extractCommitScope(commit) {
+		if (commit.scope) return commit.scope;
+		if (commit.header) return commit.header.match(ANALYSIS_PATTERNS.SCOPE_HEADER)?.[1] ?? null;
+		return null;
+	}
+	/**
+	* Analyzes the commit scope for breaking changes based on configuration.
+	*
+	* @param commit - The commit to analyze
+	* @param config - The commit type configuration
+	* @returns An array of scopes that indicate breaking changes
+	*/
+	analyzeScopeBreaking(commit, config) {
+		const scope = this.extractCommitScope(commit);
+		if (!scope) return [];
+		if (config.scopeRules[scope.toLowerCase()] === "major") return [scope];
+		return [];
+	}
+	/**
+	* Detects if the commit indicates a pre-release to stable transition.
+	*
+	* @param commit - The commit to analyze
+	* @returns True if a transition is detected, false otherwise
+	*/
+	detectPreReleaseTransition(commit) {
+		const message = commit.header?.toLowerCase() ?? "";
+		const body = commit.body?.toLowerCase() ?? "";
+		return TRANSITION_KEYWORDS.some((keyword) => message.includes(keyword) || body.includes(keyword));
+	}
+	/**
+	* Performs a detailed analysis of the commits to determine their impact on versioning.
+	*
+	* @param commits - The list of commits to analyze
+	* @param config - The commit type configuration
+	* @returns The detailed commit analysis
+	*/
+	performDetailedAnalysis(commits, config) {
+		logger.verbose("CommitAnalysisService: Performing detailed commit analysis...");
+		const analysis = commits.reduce((acc, commit) => {
+			const type = commit.type?.toLowerCase() ?? "unknown";
+			const updatedCommitsByType = { ...acc.commitsByType };
+			if (!updatedCommitsByType[type]) updatedCommitsByType[type] = [];
+			updatedCommitsByType[type] = [...updatedCommitsByType[type], commit];
+			return {
+				breakingChanges: acc.breakingChanges + this.countBreakingChanges(commit),
+				features: acc.features + (this.isFeatureCommit(commit, config) ? 1 : 0),
+				patches: acc.patches + (this.isPatchCommit(commit, config) ? 1 : 0),
+				scopedBreaking: [...acc.scopedBreaking, ...this.analyzeScopeBreaking(commit, config)],
+				hasPreReleaseTransition: acc.hasPreReleaseTransition || this.detectPreReleaseTransition(commit),
+				commitsByType: updatedCommitsByType
+			};
+		}, {
+			breakingChanges: 0,
+			features: 0,
+			patches: 0,
+			scopedBreaking: [],
+			hasPreReleaseTransition: false,
+			commitsByType: {}
+		});
+		logger.verbose(`CommitAnalysisService: Analysis results - Breaking: ${analysis.breakingChanges}, Features: ${analysis.features}, Patches: ${analysis.patches}`);
+		return analysis;
+	}
+	/**
+	* Determines the version level based on the commit analysis.
+	*
+	* @param analysis - The detailed commit analysis
+	* @returns The recommended version level
+	*/
+	determineVersionLevel(analysis) {
+		logger.verbose("CommitAnalysisService: Determining version level from analysis...");
+		if (analysis.breakingChanges > 0 || analysis.scopedBreaking.length > 0) {
+			logger.verbose("CommitAnalysisService: Breaking changes detected, recommending MAJOR version bump.");
+			return VERSION_LEVELS.MAJOR;
+		}
+		if (analysis.features > 0) {
+			logger.verbose("CommitAnalysisService: New features detected, recommending MINOR version bump.");
+			return VERSION_LEVELS.MINOR;
+		}
+		if (analysis.patches > 0) {
+			logger.verbose("CommitAnalysisService: Patch-level changes detected, recommending PATCH version bump.");
+			return VERSION_LEVELS.PATCH;
+		}
+		logger.verbose("CommitAnalysisService: No significant changes detected, defaulting to PATCH version bump.");
+		return VERSION_LEVELS.PATCH;
+	}
+	/**
+	* Generates a human-readable reason for the version recommendation.
+	*
+	* @param analysis - The detailed commit analysis
+	* @returns A string explaining the recommendation
+	*/
+	generateRecommendationReason(analysis) {
+		const reasonParts = [];
+		if (analysis.breakingChanges > 0) {
+			const plural = analysis.breakingChanges === 1 ? "change" : "changes";
+			reasonParts.push(`${analysis.breakingChanges} breaking ${plural}`);
+		}
+		if (analysis.scopedBreaking.length > 0) {
+			const scopes = analysis.scopedBreaking.join(", ");
+			reasonParts.push(`breaking scope(s): ${scopes}`);
+		}
+		if (analysis.features > 0) {
+			const plural = analysis.features === 1 ? "feature" : "features";
+			reasonParts.push(`${analysis.features} new ${plural}`);
+		}
+		if (analysis.patches > 0) {
+			const plural = analysis.patches === 1 ? "fix" : "fixes";
+			reasonParts.push(`${analysis.patches} ${plural}`);
+		}
+		if (analysis.hasPreReleaseTransition) reasonParts.push("pre-release transition detected");
+		if (reasonParts.length === 0) return "No significant changes detected, defaulting to patch increment";
+		return `Analysis found: ${reasonParts.join(", ")}`;
+	}
+	/**
+	* Creates a default patch recommendation when no commits are provided.
+	*
+	* @returns The default version recommendation
+	*/
+	createDefaultPatchRecommendation() {
+		return {
+			level: VERSION_LEVELS.PATCH,
+			releaseType: "patch",
+			reason: "No commits provided, defaulting to patch increment for safety",
+			analysis: {
+				breakingChanges: 0,
+				features: 0,
+				patches: 0,
+				scopedBreaking: [],
+				hasPreReleaseTransition: false,
+				commitsByType: {}
+			}
+		};
+	}
+	/**
+	* Builds the final version recommendation object.
+	*
+	* @param level - The determined version level
+	* @param analysis - The detailed commit analysis
+	* @returns The version recommendation
+	*/
+	buildVersionRecommendation(level, analysis) {
+		logger.verbose("CommitAnalysisService: Building version recommendation...");
+		return {
+			level,
+			releaseType: LEVEL_TO_RELEASE_TYPE[level],
+			reason: this.generateRecommendationReason(analysis),
+			analysis
+		};
+	}
+};
+/**
+* Creates a commit analysis service instance.
+* @param git - The Git service to use
+*/
+function createCommitAnalysisService(git) {
+	return new DefaultCommitAnalysisService(git);
+}
+
+//#endregion
+export { createCommitAnalysisService };

package/dist/config.d.ts

@@ -0,0 +1,68 @@
+import z from "zod";
+
+//#region src/cli/config/config.schema.d.ts
+
+/**
+ * Complete Firefly configuration schema.
+ * Combines global options with command-specific configuration sections.
+ */
+declare const FireflyConfigSchema: z.ZodObject<{
+  release: z.ZodOptional<z.ZodObject<{
+    name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    scope: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    base: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    branch: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    changelogPath: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    bumpStrategy: z.ZodOptional<z.ZodDefault<z.ZodUnion<[z.ZodEnum<{
+      auto: "auto";
+      manual: "manual";
+    }>, z.ZodLiteral<"">]>>>;
+    releaseType: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+      major: "major";
+      minor: "minor";
+      patch: "patch";
+      prerelease: "prerelease";
+      premajor: "premajor";
+      preminor: "preminor";
+      prepatch: "prepatch";
+      graduate: "graduate";
+    }>>>;
+    preReleaseId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    preReleaseBase: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"0">, z.ZodLiteral<"1">]>>>;
+    releaseNotes: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    commitMessage: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    tagName: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    skipBump: z.ZodOptional<z.ZodDefault<z.ZodCoercedBoolean<unknown>>>;
+    skipChangelog: z.ZodOptional<z.ZodDefault<z.ZodCoercedBoolean<unknown>>>;
+    skipPush: z.ZodOptional<z.ZodDefault<z.ZodCoercedBoolean<unknown>>>;
+    skipGitHubRelease: z.ZodOptional<z.ZodDefault<z.ZodCoercedBoolean<unknown>>>;
+    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.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>>;
+  verbose: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+  enableRollback: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+/**
+ * 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>;
+//#endregion
+//#region src/config/index.d.ts
+/**
+ * Helper function to define a type-safe Firefly configuration.
+ *
+ * Provides IntelliSense autocompletion and type checking for config files.
+ *
+ * @param options - The configuration options
+ * @returns The same options (identity function for type inference)
+ */
+declare function defineConfig<T extends FireflyConfig>(options: T): T;
+//#endregion
+export { defineConfig };

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-Cdg-c0EP.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-BMtOWD2-.js";
+import { t as logger } from "./logging-BuIkRrn1.js";
 
 //#region src/infrastructure/dry-run/index.ts
 /**

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

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