@muverse/core 0.1.0

package/dist/semver/index.d.ts

@@ -0,0 +1,85 @@
+import { SemVer } from "semver";
+/**
+ * Semantic version bump types: major, minor, patch, or none.
+ * Represents different ways a version can be incremented per Semantic Versioning 2.0.0.
+ */
+export type BumpType = "major" | "minor" | "patch" | "none";
+/**
+ * Parses a semantic version string into a SemVer object.
+ * @param versionString - The version string to parse (e.g., '1.2.3', '2.0.0-beta.1')
+ * @returns A parsed SemVer object with structured version components
+ * @throws {Error} If the version string is invalid or cannot be parsed
+ */
+export declare function parseSemVer(versionString: string): SemVer;
+/**
+ * Converts a SemVer object to its string representation.
+ * @param version - The SemVer object to format
+ * @returns The version as a string, preserving all components including build metadata
+ */
+export declare function formatSemVer(version: SemVer): string;
+/**
+ * Compares two semantic versions following SemVer precedence rules.
+ * @param a - The first version to compare
+ * @param b - The second version to compare
+ * @returns `-1` if a < b, `0` if a === b, `1` if a > b
+ */
+export declare function compareSemVer(a: SemVer, b: SemVer): number;
+/**
+ * Increments a semantic version based on the specified bump type.
+ * @param version - The version to bump
+ * @param bumpType - The type of version increment to apply
+ * @returns A new SemVer object with the incremented version
+ * @throws {Error} If the version cannot be bumped with the specified type
+ */
+export declare function bumpSemVer(version: SemVer, bumpType: BumpType): SemVer;
+/**
+ * Determines the bump type between two versions.
+ * @param from - The starting version
+ * @param to - The ending version
+ * @returns The bump type that would transform 'from' into 'to'
+ */
+export declare function getBumpType(from: SemVer, to: SemVer): BumpType;
+/**
+ * Determines the highest priority bump type from an array.
+ * Priority: major > minor > patch > none.
+ * @param bumpTypes - Array of bump types to evaluate
+ * @returns The bump type with highest priority
+ */
+export declare function maxBumpType(bumpTypes: BumpType[]): BumpType;
+/**
+ * Validates whether a string is a valid semantic version.
+ * @param versionString - The version string to validate
+ * @returns True if valid semantic version, false otherwise
+ */
+export declare function isValidVersionString(versionString: string): boolean;
+/**
+ * Creates an initial semantic version (0.0.0) for new modules or projects.
+ * @returns A SemVer object representing version 0.0.0
+ */
+export declare function createInitialVersion(): SemVer;
+/**
+ * Bumps a version to a prerelease version.
+ * @param version - The version to bump to prerelease
+ * @param bumpType - The type of version bump to apply before adding prerelease identifier
+ * @param prereleaseId - The prerelease identifier (e.g., 'alpha', 'beta', 'rc')
+ * @returns A new SemVer object with the prerelease version
+ * @throws {Error} If the bump operation fails
+ */
+export declare function bumpToPrerelease(version: SemVer, bumpType: BumpType, prereleaseId: string): SemVer;
+/**
+ * Adds build metadata to a semantic version.
+ * Build metadata is appended with a '+' sign and doesn't affect version precedence.
+ * @param version - The version to add metadata to
+ * @param buildMetadata - The build metadata string to append
+ * @returns A new SemVer object with the build metadata appended
+ */
+export declare function addBuildMetadata(version: SemVer, buildMetadata: string): SemVer;
+/**
+ * Generates a timestamp-based prerelease identifier in format `{baseId}.{YYYYMMDD}.{HHMM}`.
+ * Creates unique, sortable prerelease identifiers using UTC timestamps.
+ * @param baseId - The base identifier for the prerelease (e.g., 'alpha', 'beta', 'rc')
+ * @param timestamp - Optional timestamp to use; defaults to current date/time
+ * @returns A prerelease identifier string (e.g., 'alpha.20230515.1430')
+ */
+export declare function generateTimestampPrereleaseId(baseId: string, timestamp?: Date): string;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/semver/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,CAAC;AAE5D;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAQzD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAatE;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,QAAQ,CAc9D;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,QAAQ,CAM3D;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAEnE;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,QAAQ,EAClB,YAAY,EAAE,MAAM,GACnB,MAAM,CAkDR;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,GACpB,MAAM,CAMR;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,IAAI,GACf,MAAM,CAeR"}

package/dist/semver/index.js

@@ -0,0 +1,176 @@
+import * as semver from "semver";
+import { SemVer } from "semver";
+/**
+ * Parses a semantic version string into a SemVer object.
+ * @param versionString - The version string to parse (e.g., '1.2.3', '2.0.0-beta.1')
+ * @returns A parsed SemVer object with structured version components
+ * @throws {Error} If the version string is invalid or cannot be parsed
+ */
+export function parseSemVer(versionString) {
+    const parsed = semver.parse(versionString);
+    if (!parsed) {
+        throw new Error(`Invalid semantic version: ${versionString}`);
+    }
+    return parsed;
+}
+/**
+ * Converts a SemVer object to its string representation.
+ * @param version - The SemVer object to format
+ * @returns The version as a string, preserving all components including build metadata
+ */
+export function formatSemVer(version) {
+    return version.raw;
+}
+/**
+ * Compares two semantic versions following SemVer precedence rules.
+ * @param a - The first version to compare
+ * @param b - The second version to compare
+ * @returns `-1` if a < b, `0` if a === b, `1` if a > b
+ */
+export function compareSemVer(a, b) {
+    return semver.compare(a, b);
+}
+/**
+ * Increments a semantic version based on the specified bump type.
+ * @param version - The version to bump
+ * @param bumpType - The type of version increment to apply
+ * @returns A new SemVer object with the incremented version
+ * @throws {Error} If the version cannot be bumped with the specified type
+ */
+export function bumpSemVer(version, bumpType) {
+    if (bumpType === "none") {
+        return version;
+    }
+    const bumpedVersionString = semver.inc(version, bumpType);
+    if (!bumpedVersionString) {
+        throw new Error(`Failed to bump version ${version.version} with type ${bumpType}`);
+    }
+    return parseSemVer(bumpedVersionString);
+}
+/**
+ * Determines the bump type between two versions.
+ * @param from - The starting version
+ * @param to - The ending version
+ * @returns The bump type that would transform 'from' into 'to'
+ */
+export function getBumpType(from, to) {
+    if (to.major > from.major) {
+        return "major";
+    }
+    if (to.minor > from.minor) {
+        return "minor";
+    }
+    if (to.patch > from.patch) {
+        return "patch";
+    }
+    return "none";
+}
+/**
+ * Determines the highest priority bump type from an array.
+ * Priority: major > minor > patch > none.
+ * @param bumpTypes - Array of bump types to evaluate
+ * @returns The bump type with highest priority
+ */
+export function maxBumpType(bumpTypes) {
+    const priority = { none: 0, patch: 1, minor: 2, major: 3 };
+    return bumpTypes.reduce((max, current) => {
+        return priority[current] > priority[max] ? current : max;
+    }, "none");
+}
+/**
+ * Validates whether a string is a valid semantic version.
+ * @param versionString - The version string to validate
+ * @returns True if valid semantic version, false otherwise
+ */
+export function isValidVersionString(versionString) {
+    return semver.valid(versionString) !== null;
+}
+/**
+ * Creates an initial semantic version (0.0.0) for new modules or projects.
+ * @returns A SemVer object representing version 0.0.0
+ */
+export function createInitialVersion() {
+    return new SemVer("0.0.0");
+}
+/**
+ * Bumps a version to a prerelease version.
+ * @param version - The version to bump to prerelease
+ * @param bumpType - The type of version bump to apply before adding prerelease identifier
+ * @param prereleaseId - The prerelease identifier (e.g., 'alpha', 'beta', 'rc')
+ * @returns A new SemVer object with the prerelease version
+ * @throws {Error} If the bump operation fails
+ */
+export function bumpToPrerelease(version, bumpType, prereleaseId) {
+    if (bumpType === "none") {
+        // If no changes, convert current version to prerelease
+        if (version.prerelease.length > 0) {
+            // Already a prerelease, increment the prerelease version
+            const bumpedVersionString = semver.inc(version, "prerelease", prereleaseId);
+            if (!bumpedVersionString) {
+                throw new Error(`Failed to bump prerelease version ${version.version}`);
+            }
+            return parseSemVer(bumpedVersionString);
+        }
+        else {
+            // Convert to prerelease by bumping patch and adding prerelease identifier
+            const bumpedVersionString = semver.inc(version, "prepatch", prereleaseId);
+            if (!bumpedVersionString) {
+                throw new Error(`Failed to create prerelease version from ${version.version}`);
+            }
+            return parseSemVer(bumpedVersionString);
+        }
+    }
+    // Bump to prerelease version based on bump type
+    let prereleaseType;
+    switch (bumpType) {
+        case "patch":
+            prereleaseType = "prepatch";
+            break;
+        case "minor":
+            prereleaseType = "preminor";
+            break;
+        case "major":
+            prereleaseType = "premajor";
+            break;
+        default:
+            throw new Error(`Invalid bump type for prerelease: ${bumpType}`);
+    }
+    const bumpedVersionString = semver.inc(version, prereleaseType, prereleaseId);
+    if (!bumpedVersionString) {
+        throw new Error(`Failed to bump version ${version.version} to prerelease with type ${prereleaseType}`);
+    }
+    return parseSemVer(bumpedVersionString);
+}
+/**
+ * Adds build metadata to a semantic version.
+ * Build metadata is appended with a '+' sign and doesn't affect version precedence.
+ * @param version - The version to add metadata to
+ * @param buildMetadata - The build metadata string to append
+ * @returns A new SemVer object with the build metadata appended
+ */
+export function addBuildMetadata(version, buildMetadata) {
+    // Use the existing version string and append build metadata
+    const baseVersionString = version.format(); // Gets version without build metadata
+    const newVersionString = `${baseVersionString}+${buildMetadata}`;
+    return parseSemVer(newVersionString);
+}
+/**
+ * Generates a timestamp-based prerelease identifier in format `{baseId}.{YYYYMMDD}.{HHMM}`.
+ * Creates unique, sortable prerelease identifiers using UTC timestamps.
+ * @param baseId - The base identifier for the prerelease (e.g., 'alpha', 'beta', 'rc')
+ * @param timestamp - Optional timestamp to use; defaults to current date/time
+ * @returns A prerelease identifier string (e.g., 'alpha.20230515.1430')
+ */
+export function generateTimestampPrereleaseId(baseId, timestamp) {
+    const date = timestamp || new Date();
+    // Format: YYYYMMDD (using UTC to ensure consistency across timezones)
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const day = String(date.getUTCDate()).padStart(2, "0");
+    const dateString = `${year}${month}${day}`;
+    // Format: HHMM (using UTC to ensure consistency across timezones)
+    const hours = String(date.getUTCHours()).padStart(2, "0");
+    const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+    const timeString = `${hours}${minutes}`;
+    return `${baseId}.${dateString}.${timeString}`;
+}

package/dist/services/adapter-identifier-registry.d.ts

@@ -0,0 +1,38 @@
+import { AdapterIdentifier } from "./adapter-identifier.js";
+/**
+ * Registry for managing and discovering adapter identifiers.
+ * Provides automatic project adapter detection, fast lookup by ID, and discovery of supported adapters.
+ */
+export declare class AdapterIdentifierRegistry {
+    /**
+     * Internal map of adapter identifiers keyed by their unique ID.
+     */
+    private readonly identifiers;
+    /**
+     * Cached array of all supported adapter IDs.
+     */
+    private readonly supportedAdapters;
+    /**
+     * Creates a new adapter identifier registry.
+     * @param identifiers - Array of adapter identifiers to register
+     */
+    constructor(identifiers: AdapterIdentifier[]);
+    /**
+     * Automatically identifies which adapter can handle the specified project.
+     * @param projectRoot - The absolute path to the root directory of the project to analyze
+     * @returns A promise that resolves to the first matching adapter, or `null` if no adapter can handle the project
+     */
+    identify(projectRoot: string): Promise<AdapterIdentifier | null>;
+    /**
+     * Retrieves a specific adapter identifier by its unique ID.
+     * @param id - The unique identifier of the adapter to retrieve
+     * @returns The adapter if found, or `null` if not registered
+     */
+    getIdentifierById(id: string): AdapterIdentifier | null;
+    /**
+     * Returns a list of all supported adapter IDs in this registry.
+     * @returns An array of adapter ID strings
+     */
+    getSupportedAdapters(): string[];
+}
+//# sourceMappingURL=adapter-identifier-registry.d.ts.map

package/dist/services/adapter-identifier-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-identifier-registry.d.ts","sourceRoot":"","sources":["../../src/services/adapter-identifier-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAE5D;;;GAGG;AACH,qBAAa,yBAAyB;IACpC;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyC;IAErE;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAW;IAE7C;;;OAGG;gBACS,WAAW,EAAE,iBAAiB,EAAE;IAK5C;;;;OAIG;IACG,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAkBtE;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;IAIvD;;;OAGG;IACH,oBAAoB,IAAI,MAAM,EAAE;CAGjC"}

package/dist/services/adapter-identifier-registry.js

@@ -0,0 +1,59 @@
+/**
+ * Registry for managing and discovering adapter identifiers.
+ * Provides automatic project adapter detection, fast lookup by ID, and discovery of supported adapters.
+ */
+export class AdapterIdentifierRegistry {
+    /**
+     * Internal map of adapter identifiers keyed by their unique ID.
+     */
+    identifiers;
+    /**
+     * Cached array of all supported adapter IDs.
+     */
+    supportedAdapters;
+    /**
+     * Creates a new adapter identifier registry.
+     * @param identifiers - Array of adapter identifiers to register
+     */
+    constructor(identifiers) {
+        this.identifiers = new Map(identifiers.map((id) => [id.metadata.id, id]));
+        this.supportedAdapters = Array.from(this.identifiers.keys());
+    }
+    /**
+     * Automatically identifies which adapter can handle the specified project.
+     * @param projectRoot - The absolute path to the root directory of the project to analyze
+     * @returns A promise that resolves to the first matching adapter, or `null` if no adapter can handle the project
+     */
+    async identify(projectRoot) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        for (const [_, identifier] of this.identifiers) {
+            try {
+                const result = await identifier.accept(projectRoot);
+                if (result) {
+                    return identifier;
+                }
+            }
+            catch (error) {
+                // Continue to the next identifier if this one fails
+                // This ensures robustness - one faulty adapter won't break discovery
+                continue;
+            }
+        }
+        return null;
+    }
+    /**
+     * Retrieves a specific adapter identifier by its unique ID.
+     * @param id - The unique identifier of the adapter to retrieve
+     * @returns The adapter if found, or `null` if not registered
+     */
+    getIdentifierById(id) {
+        return this.identifiers.get(id) || null;
+    }
+    /**
+     * Returns a list of all supported adapter IDs in this registry.
+     * @returns An array of adapter ID strings
+     */
+    getSupportedAdapters() {
+        return this.supportedAdapters;
+    }
+}

package/dist/services/adapter-identifier.d.ts

@@ -0,0 +1,31 @@
+/** Metadata describing an adapter's identity and capabilities. */
+export type AdapterMetadata = {
+    /** Unique identifier (e.g., 'gradle', 'maven', 'npm'). */
+    readonly id: string;
+    /** Features supported by this adapter. */
+    readonly capabilities: AdapterCapabilities;
+};
+/** Feature capabilities of an adapter. */
+export type AdapterCapabilities = {
+    /** Whether the adapter supports snapshot versions (e.g., '1.0.0-SNAPSHOT'). */
+    readonly supportsSnapshots: boolean;
+};
+/**
+ * Interface for adapter identification and auto-discovery.
+ *
+ * @remarks
+ * Implementations identify which adapter can handle a project by checking for
+ * build-system-specific files (e.g., build.gradle, pom.xml, package.json).
+ */
+export interface AdapterIdentifier {
+    /** Adapter metadata with ID and capabilities. */
+    readonly metadata: AdapterMetadata;
+    /**
+     * Determines whether this adapter can handle the specified project.
+     *
+     * @param projectRoot - Absolute path to project root
+     * @returns `true` if adapter can handle the project, `false` otherwise
+     */
+    accept(projectRoot: string): Promise<boolean>;
+}
+//# sourceMappingURL=adapter-identifier.d.ts.map

package/dist/services/adapter-identifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-identifier.d.ts","sourceRoot":"","sources":["../../src/services/adapter-identifier.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,MAAM,MAAM,eAAe,GAAG;IAC5B,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB,0CAA0C;IAC1C,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;CAC5C,CAAC;AAEF,0CAA0C;AAC1C,MAAM,MAAM,mBAAmB,GAAG;IAChC,+EAA+E;IAC/E,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;CACrC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC,iDAAiD;IACjD,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IAEnC;;;;;OAKG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC/C"}

package/dist/services/adapter-identifier.js

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

package/dist/services/adapter-metadata-provider.d.ts

@@ -0,0 +1,51 @@
+import { AdapterMetadata } from "./adapter-identifier.js";
+import { AdapterIdentifierRegistry } from "./adapter-identifier-registry.js";
+/**
+ * Configuration options for the adapter metadata provider.
+ */
+export type AdapterMetadataProviderOptions = {
+    /**
+     * Optional explicit adapter identifier. When provided, overrides auto-detection.
+     */
+    adapter?: string;
+    /**
+     * The absolute path to the repository root directory.
+     */
+    repoRoot: string;
+};
+/**
+ * Provides adapter metadata with support for explicit specification and auto-detection.
+ */
+export declare class AdapterMetadataProvider {
+    private readonly adapterIdentifierRegistry;
+    private readonly options;
+    /**
+     * The normalized adapter ID from options, if provided.
+     */
+    private readonly adapterId;
+    /**
+     * Creates a new adapter metadata provider.
+     * @param adapterIdentifierRegistry - The registry containing all available adapter identifiers
+     * @param options - Configuration options for adapter resolution
+     */
+    constructor(adapterIdentifierRegistry: AdapterIdentifierRegistry, options: AdapterMetadataProviderOptions);
+    /**
+     * Retrieves the metadata for the resolved adapter.
+     * @returns A promise that resolves to the adapter metadata
+     * @throws {Error} If the specified adapter is not supported or no adapter can be auto-detected
+     */
+    getMetadata(): Promise<AdapterMetadata>;
+    /**
+     * Attempts to retrieve the explicitly specified adapter.
+     * @returns A promise that resolves to the adapter if specified and found, or `null` if not specified
+     * @throws {Error} If an adapter was specified but is not registered in the registry
+     */
+    private getSpecifiedAdapter;
+    /**
+     * Attempts to automatically detect the appropriate adapter for the project.
+     * @returns A promise that resolves to the auto-detected adapter
+     * @throws {Error} If no adapter could be detected for the project
+     */
+    private getAutoDetectedAdapter;
+}
+//# sourceMappingURL=adapter-metadata-provider.d.ts.map

package/dist/services/adapter-metadata-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-metadata-provider.d.ts","sourceRoot":"","sources":["../../src/services/adapter-metadata-provider.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAqB,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EAAE,yBAAyB,EAAE,MAAM,kCAAkC,CAAC;AAE7E;;GAEG;AACH,MAAM,MAAM,8BAA8B,GAAG;IAC3C;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;GAEG;AACH,qBAAa,uBAAuB;IAYhC,OAAO,CAAC,QAAQ,CAAC,yBAAyB;IAC1C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAZ1B;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqB;IAE/C;;;;OAIG;gBAEgB,yBAAyB,EAAE,yBAAyB,EACpD,OAAO,EAAE,8BAA8B;IAK1D;;;;OAIG;IACG,WAAW,IAAI,OAAO,CAAC,eAAe,CAAC;IAQ7C;;;;OAIG;YACW,mBAAmB;IAoBjC;;;;OAIG;YACW,sBAAsB;CAiBrC"}

package/dist/services/adapter-metadata-provider.js

@@ -0,0 +1,66 @@
+import { logger } from "../utils/logger.js";
+/**
+ * Provides adapter metadata with support for explicit specification and auto-detection.
+ */
+export class AdapterMetadataProvider {
+    adapterIdentifierRegistry;
+    options;
+    /**
+     * The normalized adapter ID from options, if provided.
+     */
+    adapterId;
+    /**
+     * Creates a new adapter metadata provider.
+     * @param adapterIdentifierRegistry - The registry containing all available adapter identifiers
+     * @param options - Configuration options for adapter resolution
+     */
+    constructor(adapterIdentifierRegistry, options) {
+        this.adapterIdentifierRegistry = adapterIdentifierRegistry;
+        this.options = options;
+        this.adapterId = options.adapter?.toLowerCase();
+    }
+    /**
+     * Retrieves the metadata for the resolved adapter.
+     * @returns A promise that resolves to the adapter metadata
+     * @throws {Error} If the specified adapter is not supported or no adapter can be auto-detected
+     */
+    async getMetadata() {
+        let identifier = await this.getSpecifiedAdapter();
+        if (!identifier) {
+            identifier = await this.getAutoDetectedAdapter();
+        }
+        return identifier.metadata;
+    }
+    /**
+     * Attempts to retrieve the explicitly specified adapter.
+     * @returns A promise that resolves to the adapter if specified and found, or `null` if not specified
+     * @throws {Error} If an adapter was specified but is not registered in the registry
+     */
+    async getSpecifiedAdapter() {
+        if (!this.adapterId)
+            return null;
+        const identifier = this.adapterIdentifierRegistry.getIdentifierById(this.adapterId);
+        if (!identifier) {
+            throw new Error(`Unsupported adapter '${this.adapterId}'. Supported adapters: ${this.adapterIdentifierRegistry
+                .getSupportedAdapters()
+                .join(", ")}`);
+        }
+        logger.info(`📝 Using explicitly provided adapter: ${this.adapterId}`);
+        return identifier;
+    }
+    /**
+     * Attempts to automatically detect the appropriate adapter for the project.
+     * @returns A promise that resolves to the auto-detected adapter
+     * @throws {Error} If no adapter could be detected for the project
+     */
+    async getAutoDetectedAdapter() {
+        const identifier = await this.adapterIdentifierRegistry.identify(this.options.repoRoot);
+        if (!identifier) {
+            throw new Error("No project adapter could be auto-detected. " +
+                'Please specify the "adapter" input explicitly in your workflow. ' +
+                "Supported adapters: gradle. For more information, see the documentation.");
+        }
+        logger.info(`🔍 Auto-detected adapter: ${identifier.metadata.id}`);
+        return identifier;
+    }
+}

package/dist/services/changelog-generator.d.ts

@@ -0,0 +1,13 @@
+import { ModuleChangeResult } from "./version-applier.js";
+import { CommitInfo } from "../git/index.js";
+export type ChangelogGeneratorOptions = {
+    generateChangelog: boolean;
+    repoRoot: string;
+    dryRun: boolean;
+};
+export declare class ChangelogGenerator {
+    private readonly options;
+    constructor(options: ChangelogGeneratorOptions);
+    generateChangelogs(moduleResults: ModuleChangeResult[], moduleCommits: Map<string, CommitInfo[]>): Promise<string[]>;
+}
+//# sourceMappingURL=changelog-generator.d.ts.map

package/dist/services/changelog-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"changelog-generator.d.ts","sourceRoot":"","sources":["../../src/services/changelog-generator.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,MAAM,MAAM,yBAAyB,GAAG;IACtC,iBAAiB,EAAE,OAAO,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,qBAAa,kBAAkB;IACjB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,yBAAyB;IAEzD,kBAAkB,CACtB,aAAa,EAAE,kBAAkB,EAAE,EACnC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC,GACvC,OAAO,CAAC,MAAM,EAAE,CAAC;CAgCrB"}

package/dist/services/changelog-generator.js

@@ -0,0 +1,26 @@
+import { logger } from "../utils/logger.js";
+import { generateChangelogsForModules, generateRootChangelog, } from "../changelog/index.js";
+export class ChangelogGenerator {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async generateChangelogs(moduleResults, moduleCommits) {
+        if (!this.options.generateChangelog) {
+            logger.info("📚 Skipping changelog generation (disabled by generate-changelog input)");
+            return [];
+        }
+        logger.info("📚 Generating changelogs...");
+        if (this.options.dryRun) {
+            logger.info("🏃‍♂️ Dry run mode - changelogs will not be written to files");
+            return [];
+        }
+        // Generate individual module changelogs
+        const changelogPaths = await generateChangelogsForModules(moduleResults, async (moduleId) => moduleCommits.get(moduleId) || [], this.options.repoRoot);
+        // Generate root changelog
+        const rootChangelogPath = await generateRootChangelog(moduleResults, this.options.repoRoot);
+        changelogPaths.push(rootChangelogPath);
+        logger.info(`📝 Generated ${changelogPaths.length} changelog files`);
+        return changelogPaths;
+    }
+}

package/dist/services/commit-analyzer.d.ts

@@ -0,0 +1,44 @@
+import { CommitInfo } from "../git/index.js";
+import { ModuleRegistry } from "./module-registry.js";
+/**
+ * Analyzes git commits for each module, preventing double-counting in hierarchical structures.
+ *
+ * @remarks
+ * Filters out child module commits from parent modules to ensure each commit is counted
+ * only in the most specific module it affects.
+ */
+export declare class CommitAnalyzer {
+    private readonly moduleRegistry;
+    private readonly repoRoot;
+    /**
+     * Creates a new CommitAnalyzer.
+     *
+     * @param moduleRegistry - Registry with all discovered modules
+     * @param repoRoot - Absolute path to repository root
+     */
+    constructor(moduleRegistry: ModuleRegistry, repoRoot: string);
+    /**
+     * Analyzes commits since the last release for all modules.
+     *
+     * @returns Map of module ID to array of {@link CommitInfo} objects
+     * @throws {Error} If git operations fail
+     */
+    analyzeCommitsSinceLastRelease(): Promise<Map<string, CommitInfo[]>>;
+    /**
+     * Finds all child module paths for exclusion during commit analysis.
+     *
+     * @param modulePath - Parent module path
+     * @param moduleId - Parent module ID
+     * @returns Array of child module paths
+     */
+    private findChildModulePaths;
+    /**
+     * Checks if a path is a child subdirectory of a parent path.
+     *
+     * @param childPath - Path to test
+     * @param parentPath - Potential parent path
+     * @returns `true` if childPath is a subdirectory of parentPath
+     */
+    private isChildPath;
+}
+//# sourceMappingURL=commit-analyzer.d.ts.map

package/dist/services/commit-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit-analyzer.d.ts","sourceRoot":"","sources":["../../src/services/commit-analyzer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAA0B,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD;;;;;;GAMG;AACH,qBAAa,cAAc;IAQvB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAR3B;;;;;OAKG;gBAEgB,cAAc,EAAE,cAAc,EAC9B,QAAQ,EAAE,MAAM;IAGnC;;;;;OAKG;IACG,8BAA8B,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;IA8C1E;;;;;;OAMG;IACH,OAAO,CAAC,oBAAoB;IAiB5B;;;;;;OAMG;IACH,OAAO,CAAC,WAAW;CAUpB"}