@muverse/core 0.1.0

package/dist/services/version-bumper.js

@@ -0,0 +1,291 @@
+/**
+ * Version Bumper Service for μVERSE.
+ * Implements core version calculation logic: analyzes commits, cascades changes through
+ * dependencies, and applies versions with support for prereleases, metadata, and snapshots.
+ */
+import { logger } from "../utils/logger.js";
+import { getDependencyBumpType } from "../config/index.js";
+import { calculateBumpFromCommits } from "../utils/commits.js";
+import { bumpSemVer, bumpToPrerelease, formatSemVer, addBuildMetadata, generateTimestampPrereleaseId, maxBumpType, } from "../semver/index.js";
+import { getCurrentCommitShortSha } from "../git/index.js";
+import { applySnapshotSuffix } from "../utils/versioning.js";
+/**
+ * Service for calculating version bumps across modules.
+ * Handles commit analysis, dependency cascade effects, and various versioning strategies
+ * (regular, prerelease, snapshot).
+ */
+export class VersionBumper {
+    moduleRegistry;
+    options;
+    /**
+     * Creates a new VersionBumper instance.
+     * @param moduleRegistry - Registry containing all modules and their interdependencies
+     * @param options - Configuration options controlling version bump behavior
+     */
+    constructor(moduleRegistry, options) {
+        this.moduleRegistry = moduleRegistry;
+        this.options = options;
+    }
+    /**
+     * Calculates version bumps for all modules based on their commits.
+     * Orchestrates a three-phase process: initial bumps (commit analysis), cascade effects (dependency propagation),
+     * and version application (applying strategies like prerelease, timestamps, build metadata).
+     * @param moduleCommits - Map of module IDs to their commits since last version
+     * @returns Promise resolving to array of processed module changes (only modules that need updates)
+     * @throws {Error} If git operations fail
+     */
+    async calculateVersionBumps(moduleCommits) {
+        logger.info("🔢 Calculating version bumps from commits...");
+        // Generate timestamp-based prerelease ID if timestamp versions are enabled
+        let effectivePrereleaseId = this.options.prereleaseId;
+        if (this.options.timestampVersions && this.options.prereleaseMode) {
+            effectivePrereleaseId = generateTimestampPrereleaseId(this.options.prereleaseId);
+            logger.info(`🕐 Generated timestamp prerelease ID: ${effectivePrereleaseId}`);
+        }
+        // Get current commit short SHA if build metadata is enabled
+        let shortSha;
+        if (this.options.addBuildMetadata) {
+            shortSha = await getCurrentCommitShortSha({ cwd: this.options.repoRoot });
+            logger.info(`📋 Build metadata will include short SHA: ${shortSha}`);
+        }
+        // Step 1: Calculate initial bump types for all modules
+        const processingModuleChanges = this.calculateInitialBumps(moduleCommits);
+        // Step 2: Calculate cascade effects
+        logger.info("🌊 Calculating cascade effects...");
+        const cascadedChanges = this.calculateCascadeEffects(processingModuleChanges);
+        // Step 3: Apply version calculations and transformations
+        logger.info("🔢 Calculating actual versions...");
+        return this.applyVersionCalculations(cascadedChanges, effectivePrereleaseId, shortSha);
+    }
+    /**
+     * Calculates initial version bump types for all modules based on commits.
+     *
+     * This is Phase 1 of the version calculation process. It analyzes commits for each
+     * module to determine the required version bump type using Conventional Commits
+     * specification.
+     *
+     * The method creates a `ProcessingModuleChange` for **every** module in the registry,
+     * not just those with commits. The `needsProcessing` flag determines which modules
+     * will ultimately be updated.
+     *
+     * **Processing Decision Logic**:
+     * - Module has commits requiring bump: `needsProcessing = true, reason = 'commits'`
+     * - Prerelease mode with bumpUnchanged: `needsProcessing = true, reason = 'prerelease-unchanged'`
+     * - Build metadata enabled: `needsProcessing = true, reason = 'build-metadata'`
+     * - Otherwise: `needsProcessing = false, reason = 'unchanged'`
+     *
+     * @param moduleCommits - Map of module IDs to their commits since last version.
+     *
+     * @returns Array of processing module changes for all modules in the registry
+     */
+    calculateInitialBumps(moduleCommits) {
+        const processingModuleChanges = [];
+        // Iterate through ALL modules in the registry
+        for (const [projectId, projectInfo] of this.moduleRegistry.getModules()) {
+            const commits = moduleCommits.get(projectId) || [];
+            // Determine bump type from commits only
+            // Uses Conventional Commits spec to analyze commit types
+            const bumpType = calculateBumpFromCommits(commits, this.options.config);
+            // Determine processing requirements and reason
+            let reason = "unchanged";
+            let needsProcessing = false;
+            if (bumpType !== "none") {
+                // Module has commits that require version changes
+                needsProcessing = true;
+                reason = "commits";
+            }
+            else if (this.options.prereleaseMode && this.options.bumpUnchanged) {
+                // Prerelease mode with bumpUnchanged - include modules with no changes
+                needsProcessing = true;
+                reason = "prerelease-unchanged";
+            }
+            else if (this.options.addBuildMetadata) {
+                // Build metadata mode - all modules need updates for metadata
+                needsProcessing = true;
+                reason = "build-metadata";
+            }
+            // Create module change for ALL modules - processing flag determines behavior
+            processingModuleChanges.push({
+                module: projectInfo,
+                fromVersion: projectInfo.version,
+                toVersion: "", // Will be calculated later
+                bumpType: bumpType,
+                reason: reason,
+                needsProcessing: needsProcessing,
+            });
+        }
+        return processingModuleChanges;
+    }
+    /**
+     * Calculates cascade effects when modules change.
+     *
+     * This is Phase 2 of the version calculation process. It propagates version changes
+     * through the module dependency graph, ensuring that when a module changes, all
+     * modules that depend on it are also bumped appropriately.
+     *
+     * **Algorithm**: Uses a breadth-first traversal of the dependency graph:
+     * 1. Start with all modules marked for processing (needsProcessing = true)
+     * 2. For each module being processed, find all modules that depend on it
+     * 3. Calculate required bump for dependents using dependency bump rules
+     * 4. If dependent needs a higher bump, update it and add to processing queue
+     * 5. Continue until no more cascades are needed
+     *
+     * **Complexity**: O(V + E) where V = number of modules, E = number of dependencies
+     *
+     * **In-Place Modification**: This method modifies the input array in place for
+     * efficiency. The same array reference is returned with cascade effects applied.
+     *
+     * @param allModuleChanges - Array of all module changes (will be modified in place).
+     *                          Should include all modules from calculateInitialBumps().
+     *
+     * @returns The same array with cascade effects applied
+     */
+    calculateCascadeEffects(allModuleChanges) {
+        const processed = new Set();
+        const moduleMap = new Map();
+        // Create module map for O(1) lookups
+        for (const change of allModuleChanges) {
+            moduleMap.set(change.module.id, change);
+        }
+        // Start with ALL modules - treat them completely equally
+        const queue = [...allModuleChanges];
+        while (queue.length > 0) {
+            const currentChange = queue.shift();
+            // No processing needed, mark as processed
+            if (!currentChange.needsProcessing || currentChange.bumpType === "none") {
+                logger.debug(`🔄 Skipping module ${currentChange.module.id} - no processing needed`);
+                processed.add(currentChange.module.id);
+                continue;
+            }
+            // Skip if already processed
+            if (processed.has(currentChange.module.id)) {
+                logger.debug(`🔄 Skipping module ${currentChange.module.id} - already processed`);
+                continue;
+            }
+            // Mark as processed to avoid duplicate work
+            processed.add(currentChange.module.id);
+            const currentModuleInfo = this.moduleRegistry.getModule(currentChange.module.id);
+            // Iterate through all modules that depend on the current module
+            for (const dependentName of currentModuleInfo.affectedModules) {
+                logger.debug(`➡️ Processing dependent module ${dependentName} affected by ${currentChange.module.id} with bump ${currentChange.bumpType}`);
+                // Get the dependent module using O(1) lookup
+                const existingChange = moduleMap.get(dependentName);
+                if (!existingChange) {
+                    logger.debug(`⚠️ Dependent module ${dependentName} not found in module changes list`);
+                    continue; // Module not found in our module list
+                }
+                // Calculate the bump needed for the dependent
+                // Uses configuration rules to determine how changes propagate
+                const requiredBump = getDependencyBumpType(currentChange.bumpType, this.options.config);
+                if (requiredBump === "none") {
+                    logger.debug(`➡️ No cascade bump needed for module ${dependentName} from ${currentChange.module.id}`);
+                    continue; // No cascade needed
+                }
+                // Update the existing change with cascade information
+                // Take the maximum bump type if multiple dependencies affect this module
+                const mergedBump = maxBumpType([existingChange.bumpType, requiredBump]);
+                if (mergedBump !== existingChange.bumpType) {
+                    logger.debug(`🔄 Cascading bump for module ${dependentName} from ${existingChange.bumpType} to ${mergedBump} due to ${currentChange.module.id}`);
+                    // Update the module change in place
+                    existingChange.bumpType = mergedBump;
+                    existingChange.reason = "cascade";
+                    existingChange.needsProcessing = true;
+                    // Add to queue for further processing (transitive cascades)
+                    processed.delete(dependentName); // Allow re-processing
+                    queue.push(existingChange);
+                }
+                else {
+                    logger.debug(`🔄 No changes needed for module ${dependentName} - already at ${existingChange.bumpType}`);
+                }
+            }
+        }
+        // Return the modified array (same reference, but with cascade effects applied)
+        return allModuleChanges;
+    }
+    /**
+     * Applies version calculations and transformations to all modules.
+     *
+     * This is Phase 3 (final) of the version calculation process. It takes modules
+     * with calculated bump types and applies version transformations including:
+     * - Semantic version bumping (major, minor, patch)
+     * - Prerelease version generation
+     * - Build metadata appending
+     * - Snapshot suffix appending
+     *
+     * **Version Application Scenarios**:
+     * 1. **Commits + Regular Mode**: Bump semantic version normally
+     * 2. **Commits + Prerelease Mode**: Bump to prerelease version
+     * 3. **No Commits + Prerelease + bumpUnchanged**: Force prerelease bump
+     * 4. **Build Metadata Mode**: Append git SHA as metadata
+     * 5. **Snapshot Mode**: Append -SNAPSHOT suffix
+     *
+     * @param processingModuleChanges - All module changes with calculated bump types
+     *                                 from cascade effects phase.
+     *
+     * @param effectivePrereleaseId - Prerelease identifier to use (may include timestamp).
+     *                               Example: 'alpha', 'alpha.20251021143022'
+     *
+     * @param shortSha - Optional git commit short SHA for build metadata.
+     *                  Example: 'a1b2c3d'
+     *
+     * @returns Array of processed module changes ready for application (only modules with needsProcessing = true)
+     */
+    applyVersionCalculations(processingModuleChanges, effectivePrereleaseId, shortSha) {
+        const processedModuleChanges = [];
+        for (const change of processingModuleChanges) {
+            let newVersion = change.fromVersion;
+            // Only apply version changes if module needs processing
+            if (change.needsProcessing) {
+                // Apply version bumps based on module state
+                if (change.bumpType !== "none" && this.options.prereleaseMode) {
+                    // Scenario 1: Commits with changes in prerelease mode
+                    // Bump semantic version AND add prerelease identifier
+                    newVersion = bumpToPrerelease(change.fromVersion, change.bumpType, effectivePrereleaseId);
+                }
+                else if (change.bumpType !== "none" && !this.options.prereleaseMode) {
+                    // Scenario 2: Commits with changes in normal mode
+                    // Standard semantic version bump (major.minor.patch)
+                    newVersion = bumpSemVer(change.fromVersion, change.bumpType);
+                }
+                else if (change.reason === "prerelease-unchanged") {
+                    // Scenario 3: No changes but force prerelease bump (bumpUnchanged enabled)
+                    // Keep semantic version, just add prerelease identifier
+                    newVersion = bumpToPrerelease(change.fromVersion, "none", effectivePrereleaseId);
+                }
+                // Scenario 4: reason === 'build-metadata' or 'unchanged' - no version bump, keep fromVersion
+                // Add build metadata if enabled (applies to all scenarios)
+                // Build metadata doesn't affect version precedence per semver spec
+                if (this.options.addBuildMetadata && shortSha) {
+                    newVersion = addBuildMetadata(newVersion, shortSha);
+                }
+            }
+            // Convert to string version
+            change.toVersion = formatSemVer(newVersion);
+            // Apply append snapshot suffix if enabled (to all modules in append mode)
+            if (this.options.appendSnapshot &&
+                this.options.adapter.capabilities.supportsSnapshots) {
+                const originalVersion = change.toVersion;
+                change.toVersion = applySnapshotSuffix(change.toVersion);
+                // If snapshot suffix was actually added and module wasn't already being processed, mark it for processing
+                if (!change.needsProcessing && change.toVersion !== originalVersion) {
+                    change.needsProcessing = true;
+                    change.reason = "gradle-snapshot";
+                }
+            }
+            // Add to update collection only if module needs processing
+            if (change.needsProcessing) {
+                // Convert to ProcessedModuleChange since we know needsProcessing is true
+                const processedChange = {
+                    module: change.module,
+                    fromVersion: change.fromVersion,
+                    toVersion: change.toVersion,
+                    bumpType: change.bumpType,
+                    reason: change.reason, // Safe cast since needsProcessing is true
+                };
+                processedModuleChanges.push(processedChange);
+            }
+        }
+        logger.info(`📈 Calculated versions for ${processedModuleChanges.length} modules requiring updates`);
+        return processedModuleChanges;
+    }
+}

package/dist/services/version-manager.d.ts

@@ -0,0 +1,68 @@
+import { SemVer } from "semver";
+import { ModuleRegistry } from "./module-registry.js";
+import { VersionUpdateStrategy } from "./version-update-strategy.js";
+/**
+ * Manages version updates for modules with staged commits and batch persistence.
+ *
+ * @remarks
+ * Implements a two-phase update strategy:
+ * 1. Stage updates in memory via `updateVersion()`
+ * 2. Persist all updates via `commit()`
+ *
+ * Uses {@link VersionUpdateStrategy} for build system-specific operations.
+ * Validates modules against {@link ModuleRegistry}.
+ */
+export declare class VersionManager {
+    private readonly hierarchyManager;
+    private readonly strategy;
+    /** Pending version updates awaiting commit (module ID → version string). */
+    private readonly pendingUpdates;
+    /**
+     * Creates a new VersionManager.
+     *
+     * @param hierarchyManager - Module registry for validation
+     * @param strategy - Build system-specific strategy for writing updates
+     */
+    constructor(hierarchyManager: ModuleRegistry, strategy: VersionUpdateStrategy);
+    /**
+     * Stages a version update for a module without persisting to files.
+     *
+     * @param moduleId - Module identifier (e.g., `':'`, `':core'`)
+     * @param newVersion - New version as SemVer object or string
+     * @throws {Error} If module ID doesn't exist in registry
+     */
+    updateVersion(moduleId: string, newVersion: SemVer | string): void;
+    /**
+     * Commits all pending version updates to build files in a single batch operation.
+     *
+     * @returns Promise that resolves when all updates are written
+     * @throws {Error} If file operations fail (specific errors depend on strategy)
+     */
+    commit(): Promise<void>;
+    /**
+     * Returns a copy of all pending updates that haven't been committed.
+     *
+     * @returns Map of module ID to version string
+     */
+    getPendingUpdates(): Map<string, string>;
+    /**
+     * Checks whether there are any pending updates awaiting commit.
+     *
+     * @returns `true` if updates are staged, `false` otherwise
+     */
+    hasPendingUpdates(): boolean;
+    /**
+     * Clears all pending updates without committing them.
+     *
+     * @remarks
+     * Use with caution - this operation cannot be undone.
+     */
+    clearPendingUpdates(): void;
+    /**
+     * Gets the number of pending updates in the queue.
+     *
+     * @returns The count of pending updates that have not been processed yet.
+     */
+    getPendingUpdatesCount(): number;
+}
+//# sourceMappingURL=version-manager.d.ts.map

package/dist/services/version-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-manager.d.ts","sourceRoot":"","sources":["../../src/services/version-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAGrE;;;;;;;;;;GAUG;AACH,qBAAa,cAAc;IAWvB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAX3B,4EAA4E;IAC5E,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6B;IAE5D;;;;;OAKG;gBAEgB,gBAAgB,EAAE,cAAc,EAChC,QAAQ,EAAE,qBAAqB;IAGlD;;;;;;OAMG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAclE;;;;;OAKG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAa7B;;;;OAIG;IACH,iBAAiB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAIxC;;;;OAIG;IACH,iBAAiB,IAAI,OAAO;IAI5B;;;;;OAKG;IACH,mBAAmB,IAAI,IAAI;IAI3B;;;;OAIG;IACH,sBAAsB,IAAI,MAAM;CAGjC"}

package/dist/services/version-manager.js

@@ -0,0 +1,94 @@
+import { formatSemVer } from "../semver/index.js";
+/**
+ * Manages version updates for modules with staged commits and batch persistence.
+ *
+ * @remarks
+ * Implements a two-phase update strategy:
+ * 1. Stage updates in memory via `updateVersion()`
+ * 2. Persist all updates via `commit()`
+ *
+ * Uses {@link VersionUpdateStrategy} for build system-specific operations.
+ * Validates modules against {@link ModuleRegistry}.
+ */
+export class VersionManager {
+    hierarchyManager;
+    strategy;
+    /** Pending version updates awaiting commit (module ID → version string). */
+    pendingUpdates = new Map();
+    /**
+     * Creates a new VersionManager.
+     *
+     * @param hierarchyManager - Module registry for validation
+     * @param strategy - Build system-specific strategy for writing updates
+     */
+    constructor(hierarchyManager, strategy) {
+        this.hierarchyManager = hierarchyManager;
+        this.strategy = strategy;
+    }
+    /**
+     * Stages a version update for a module without persisting to files.
+     *
+     * @param moduleId - Module identifier (e.g., `':'`, `':core'`)
+     * @param newVersion - New version as SemVer object or string
+     * @throws {Error} If module ID doesn't exist in registry
+     */
+    updateVersion(moduleId, newVersion) {
+        // Validate module exists in registry
+        if (!this.hierarchyManager.hasModule(moduleId)) {
+            throw new Error(`Module ${moduleId} not found`);
+        }
+        // Convert SemVer to string if needed, otherwise use string directly
+        const versionString = typeof newVersion === "string" ? newVersion : formatSemVer(newVersion);
+        // Store update in pending updates map
+        this.pendingUpdates.set(moduleId, versionString);
+    }
+    /**
+     * Commits all pending version updates to build files in a single batch operation.
+     *
+     * @returns Promise that resolves when all updates are written
+     * @throws {Error} If file operations fail (specific errors depend on strategy)
+     */
+    async commit() {
+        // Early return if nothing to commit
+        if (this.pendingUpdates.size === 0) {
+            return; // Nothing to commit
+        }
+        // Write all version updates using build system-specific strategy
+        await this.strategy.writeVersionUpdates(this.pendingUpdates);
+        // Clear the pending updates after successful commit
+        this.pendingUpdates.clear();
+    }
+    /**
+     * Returns a copy of all pending updates that haven't been committed.
+     *
+     * @returns Map of module ID to version string
+     */
+    getPendingUpdates() {
+        return new Map(this.pendingUpdates);
+    }
+    /**
+     * Checks whether there are any pending updates awaiting commit.
+     *
+     * @returns `true` if updates are staged, `false` otherwise
+     */
+    hasPendingUpdates() {
+        return this.pendingUpdates.size > 0;
+    }
+    /**
+     * Clears all pending updates without committing them.
+     *
+     * @remarks
+     * Use with caution - this operation cannot be undone.
+     */
+    clearPendingUpdates() {
+        this.pendingUpdates.clear();
+    }
+    /**
+     * Gets the number of pending updates in the queue.
+     *
+     * @returns The count of pending updates that have not been processed yet.
+     */
+    getPendingUpdatesCount() {
+        return this.pendingUpdates.size;
+    }
+}

package/dist/services/version-update-strategy.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Strategy for writing version updates to build system-specific files.
+ *
+ * @remarks
+ * Implementations handle version persistence for different build systems (Gradle, Maven, npm).
+ * Created by {@link ModuleSystemFactory} and used by {@link VersionManager}.
+ */
+export interface VersionUpdateStrategy {
+    /**
+     * Writes version updates for multiple modules to build system configuration files.
+     *
+     * @param moduleVersions - Map of module ID to new version string
+     * @returns Promise that resolves when all updates are written
+     * @throws {Error} If build files cannot be found, are not writable, or I/O operations fail
+     */
+    writeVersionUpdates(moduleVersions: Map<string, string>): Promise<void>;
+}
+//# sourceMappingURL=version-update-strategy.d.ts.map

package/dist/services/version-update-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-update-strategy.d.ts","sourceRoot":"","sources":["../../src/services/version-update-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;OAMG;IACH,mBAAmB,CAAC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzE"}

package/dist/services/version-update-strategy.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/banner.d.ts

@@ -0,0 +1,2 @@
+export declare const banner: string;
+//# sourceMappingURL=banner.d.ts.map

package/dist/utils/banner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"banner.d.ts","sourceRoot":"","sources":["../../src/utils/banner.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,MAAM,EAAE,MAOpB,CAAC"}

package/dist/utils/banner.js

@@ -0,0 +1,8 @@
+export const banner = `
+██╗   ██╗███████╗██████╗ ███████╗███████╗
+██║   ██║██╔════╝██╔══██╗██╔════╝██╔════╝
+██║   ██║█████╗  ██████╔╝███████╗█████╗  
+╚██╗ ██╔╝██╔══╝  ██╔══██╗╚════██║██╔══╝  
+ ╚████╔╝ ███████╗██║  ██║███████║███████╗
+  ╚═══╝  ╚══════╝╚═╝  ╚═╝╚══════╝╚══════╝
+`;

package/dist/utils/commits.d.ts

@@ -0,0 +1,12 @@
+import { Config } from "../config/index.js";
+import { CommitInfo } from "../git/index.js";
+import { BumpType } from "../semver/index.js";
+/**
+ * Calculates the overall semantic version bump type from a collection of commits.
+ * Returns the highest bump type: major > minor > patch > none.
+ * @param commits - Array of commit information to analyze
+ * @param config - Configuration containing commit type mappings
+ * @returns The highest BumpType required across all commits
+ */
+export declare function calculateBumpFromCommits(commits: CommitInfo[], config: Config): BumpType;
+//# sourceMappingURL=commits.d.ts.map

package/dist/utils/commits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commits.d.ts","sourceRoot":"","sources":["../../src/utils/commits.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAe,MAAM,oBAAoB,CAAC;AAE3D;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,UAAU,EAAE,EACrB,MAAM,EAAE,MAAM,GACb,QAAQ,CAiBV"}

package/dist/utils/commits.js

@@ -0,0 +1,24 @@
+import { getBumpTypeForCommit } from "../config/index.js";
+import { maxBumpType } from "../semver/index.js";
+/**
+ * Calculates the overall semantic version bump type from a collection of commits.
+ * Returns the highest bump type: major > minor > patch > none.
+ * @param commits - Array of commit information to analyze
+ * @param config - Configuration containing commit type mappings
+ * @returns The highest BumpType required across all commits
+ */
+export function calculateBumpFromCommits(commits, config) {
+    // Collect bump types for all commits
+    const bumpTypes = [];
+    // Analyze each commit and determine its version impact
+    for (const commit of commits) {
+        const bumpType = getBumpTypeForCommit(commit.type, commit.breaking, config);
+        // Only include commits that require a version bump
+        if (bumpType !== "none") {
+            bumpTypes.push(bumpType);
+        }
+    }
+    // Return the highest bump type required across all commits
+    // If no meaningful commits found, returns 'none'
+    return maxBumpType(bumpTypes);
+}

package/dist/utils/file.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks whether a file or directory exists at the specified path.
+ * @param path - Absolute or relative path to check
+ * @returns True if the path exists and is accessible, false otherwise
+ */
+export declare function exists(path: string): Promise<boolean>;
+//# sourceMappingURL=file.d.ts.map

package/dist/utils/file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/utils/file.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAW3D"}

package/dist/utils/file.js

@@ -0,0 +1,19 @@
+import { promises as fs } from "fs";
+/**
+ * Checks whether a file or directory exists at the specified path.
+ * @param path - Absolute or relative path to check
+ * @returns True if the path exists and is accessible, false otherwise
+ */
+export async function exists(path) {
+    try {
+        // Attempt to access the path
+        // If access succeeds, the path exists and is accessible
+        await fs.access(path);
+        return true;
+    }
+    catch {
+        // If access fails (any error), consider path as non-existent
+        // This includes ENOENT (doesn't exist) and EACCES (no permission)
+        return false;
+    }
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./commits.js";
+export * from "./file.js";
+export * from "./properties.js";
+export * from "./versioning.js";
+export * from "./logger.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,5 @@
+export * from "./commits.js";
+export * from "./file.js";
+export * from "./properties.js";
+export * from "./versioning.js";
+export * from "./logger.js";

package/dist/utils/logger.d.ts

@@ -0,0 +1,14 @@
+export interface Logger {
+    debug(message: string): void;
+    info(message: string): void;
+    warning(message: string | Error, context?: Record<string, unknown>): void;
+    error(message: string | Error, context?: Record<string, unknown>): void;
+}
+export declare function initLogger(logger: Logger): void;
+/**
+ * Convenience proxy so existing call sites can
+ * import `logger` and call methods. The proxy delegates
+ * to the mutable `_current` at call-time.
+ */
+export declare const logger: Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,MAAM;IACrB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC1E,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CACzE;AAYD,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,QAExC;AAED;;;;GAIG;AACH,eAAO,MAAM,MAAM,EAAE,MAOpB,CAAC"}

package/dist/utils/logger.js

@@ -0,0 +1,22 @@
+// default no-op
+const noopLogger = {
+    debug: (_message) => { },
+    info: (_message) => { },
+    warning: (_message, _context) => { },
+    error: (_message, _context) => { },
+};
+let _current = noopLogger;
+export function initLogger(logger) {
+    _current = logger;
+}
+/**
+ * Convenience proxy so existing call sites can
+ * import `logger` and call methods. The proxy delegates
+ * to the mutable `_current` at call-time.
+ */
+export const logger = {
+    debug: (message) => _current.debug(message),
+    info: (message) => _current.info(message),
+    warning: (message, context) => _current.warning(message, context),
+    error: (message, context) => _current.error(message, context),
+};

package/dist/utils/properties.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Updates or inserts a single property in a Java-style properties file.
+ * @param propertiesPath - Path to the properties file
+ * @param key - Property key to update or insert
+ * @param value - Property value to set
+ */
+export declare function upsertProperty(propertiesPath: string, key: string, value: string): Promise<void>;
+/**
+ * Updates or inserts multiple properties in a Java-style properties file.
+ * Updates existing properties in place, appends new ones to the end.
+ * @param propertiesPath - Path to the properties file
+ * @param properties - Map of property keys to values
+ * @throws {Error} If file operations fail
+ */
+export declare function upsertProperties(propertiesPath: string, properties: Map<string, string>): Promise<void>;
+//# sourceMappingURL=properties.d.ts.map