@muverse/core 0.1.0

package/dist/adapters/project-information.d.ts

@@ -0,0 +1,58 @@
+import { SemVer } from "semver";
+/**
+ * Represents a module within a project, containing metadata, version, and dependency information.
+ */
+export type Module = {
+    /** Unique identifier for the module within the project (e.g., ':', ':app', ':lib:core'). */
+    readonly id: string;
+    /** Human-readable name of the module. */
+    readonly name: string;
+    /** Relative path from the repository root to this module's directory. */
+    readonly path: string;
+    /** Type of the module: 'root' for top-level project or 'module' for subprojects. */
+    readonly type: "module" | "root";
+    /** Set of module IDs that are affected when this module changes. */
+    readonly affectedModules: Set<string>;
+    /** Current semantic version of the module. */
+    readonly version: SemVer;
+    /** Whether the version is explicitly declared in build configuration (vs inherited). */
+    readonly declaredVersion: boolean;
+};
+/**
+ * Structured representation of project information after processing.
+ * Provides efficient access to module information through arrays and maps.
+ */
+export type ProjectInformation = {
+    /** Array of all module identifiers in the project. */
+    readonly moduleIds: string[];
+    /** Map of module IDs to their complete module information (O(1) lookup). */
+    readonly modules: ReadonlyMap<string, Module>;
+    /** The module ID of the root project (typically ':' for Gradle). */
+    readonly rootModule: string;
+};
+/**
+ * Raw module data as extracted from the build system before processing.
+ * Similar to Module but with arrays instead of Sets and optional string version.
+ */
+export type RawModule = {
+    /** Human-readable name of the module. */
+    readonly name: string;
+    /** Relative path from repository root to the module directory. */
+    readonly path: string;
+    /** Array of module IDs affected when this module changes. */
+    readonly affectedModules: string[];
+    /** Version string if the module has a version (optional). */
+    readonly version?: string;
+    /** Type of the module in the project hierarchy. */
+    readonly type: "module" | "root";
+    /** Whether the version is explicitly declared in build configuration. */
+    readonly declaredVersion: boolean;
+};
+/**
+ * Raw project structure information as extracted from the build system.
+ * Maps module IDs to their raw module data.
+ */
+export type RawProjectInformation = {
+    readonly [id: string]: RawModule;
+};
+//# sourceMappingURL=project-information.d.ts.map

package/dist/adapters/project-information.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-information.d.ts","sourceRoot":"","sources":["../../src/adapters/project-information.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG;IACnB,4FAA4F;IAC5F,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,oFAAoF;IACpF,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;IAEjC,oEAAoE;IACpE,QAAQ,CAAC,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAEtC,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB,wFAAwF;IACxF,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,sDAAsD;IACtD,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC;IAE7B,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE9C,oEAAoE;IACpE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,kEAAkE;IAClE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,6DAA6D;IAC7D,QAAQ,CAAC,eAAe,EAAE,MAAM,EAAE,CAAC;IAEnC,6DAA6D;IAC7D,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAE1B,mDAAmD;IACnD,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;IAEjC,yEAAyE;IACzE,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC,CAAC"}

package/dist/adapters/project-information.js

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

package/dist/changelog/index.d.ts

@@ -0,0 +1,27 @@
+import { ModuleChangeResult } from "../services/version-applier.js";
+import { CommitInfo } from "../git/index.js";
+export type ChangelogEntry = {
+    readonly moduleResult: ModuleChangeResult;
+    readonly version: string;
+    readonly date: string;
+    readonly changes: {
+        readonly breaking: CommitInfo[];
+        readonly features: CommitInfo[];
+        readonly fixes: CommitInfo[];
+        readonly other: CommitInfo[];
+    };
+};
+export type ChangelogOptions = {
+    readonly includeCommitHashes: boolean;
+    readonly includeScopes: boolean;
+    readonly groupByType: boolean;
+};
+/** Generate changelog content for a module. */
+export declare function generateChangelog(moduleResult: ModuleChangeResult, commits: CommitInfo[], options?: ChangelogOptions): Promise<string>;
+/** Update or create a changelog file for a module. */
+export declare function updateChangelogFile(moduleResult: ModuleChangeResult, changelogContent: string, repoRoot: string): Promise<string>;
+/** Generate changelog for multiple modules. */
+export declare function generateChangelogsForModules(moduleResults: ModuleChangeResult[], getCommitsForModule: (moduleId: string) => Promise<CommitInfo[]>, repoRoot: string, options?: ChangelogOptions): Promise<string[]>;
+/** Generate a root changelog that summarizes all module changes. */
+export declare function generateRootChangelog(moduleResults: ModuleChangeResult[], repoRoot: string): Promise<string>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/changelog/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,YAAY,EAAE,kBAAkB,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE;QAChB,QAAQ,CAAC,QAAQ,EAAE,UAAU,EAAE,CAAC;QAChC,QAAQ,CAAC,QAAQ,EAAE,UAAU,EAAE,CAAC;QAChC,QAAQ,CAAC,KAAK,EAAE,UAAU,EAAE,CAAC;QAC7B,QAAQ,CAAC,KAAK,EAAE,UAAU,EAAE,CAAC;KAC9B,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;IACtC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC/B,CAAC;AAEF,+CAA+C;AAC/C,wBAAsB,iBAAiB,CACrC,YAAY,EAAE,kBAAkB,EAChC,OAAO,EAAE,UAAU,EAAE,EACrB,OAAO,GAAE,gBAIR,GACA,OAAO,CAAC,MAAM,CAAC,CA2BjB;AA4ED,sDAAsD;AACtD,wBAAsB,mBAAmB,CACvC,YAAY,EAAE,kBAAkB,EAChC,gBAAgB,EAAE,MAAM,EACxB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CAqDjB;AAED,+CAA+C;AAC/C,wBAAsB,4BAA4B,CAChD,aAAa,EAAE,kBAAkB,EAAE,EACnC,mBAAmB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,EAAE,CAAC,EAChE,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,MAAM,EAAE,CAAC,CAqBnB;AAED,oEAAoE;AACpE,wBAAsB,qBAAqB,CACzC,aAAa,EAAE,kBAAkB,EAAE,EACnC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CA4DjB"}

package/dist/changelog/index.js

@@ -0,0 +1,204 @@
+import { promises as fs } from "fs";
+import { join } from "path";
+/** Generate changelog content for a module. */
+export async function generateChangelog(moduleResult, commits, options = {
+    includeCommitHashes: false,
+    includeScopes: true,
+    groupByType: true,
+}) {
+    const entry = {
+        moduleResult,
+        version: moduleResult.to,
+        date: new Date().toISOString().split("T")[0], // YYYY-MM-DD format
+        changes: {
+            breaking: [],
+            features: [],
+            fixes: [],
+            other: [],
+        },
+    };
+    // Categorize commits
+    for (const commit of commits) {
+        if (commit.breaking) {
+            entry.changes.breaking.push(commit);
+        }
+        else if (commit.type === "feat") {
+            entry.changes.features.push(commit);
+        }
+        else if (commit.type === "fix") {
+            entry.changes.fixes.push(commit);
+        }
+        else if (["perf", "refactor", "style"].includes(commit.type)) {
+            entry.changes.other.push(commit);
+        }
+    }
+    return formatChangelogEntry(entry, options);
+}
+/**
+ * Format changelog entry as markdown
+ */
+function formatChangelogEntry(entry, options) {
+    const version = entry.version;
+    let changelog = `## [${version}] - ${entry.date}\n\n`;
+    // Breaking changes first
+    if (entry.changes.breaking.length > 0) {
+        changelog += "### 💥 BREAKING CHANGES\n\n";
+        for (const commit of entry.changes.breaking) {
+            changelog += formatCommitLine(commit, options) + "\n";
+        }
+        changelog += "\n";
+    }
+    // Features
+    if (entry.changes.features.length > 0) {
+        changelog += "### ✨ Features\n\n";
+        for (const commit of entry.changes.features) {
+            changelog += formatCommitLine(commit, options) + "\n";
+        }
+        changelog += "\n";
+    }
+    // Bug fixes
+    if (entry.changes.fixes.length > 0) {
+        changelog += "### 🐛 Bug Fixes\n\n";
+        for (const commit of entry.changes.fixes) {
+            changelog += formatCommitLine(commit, options) + "\n";
+        }
+        changelog += "\n";
+    }
+    // Other changes
+    if (entry.changes.other.length > 0) {
+        changelog += "### 🔧 Other Changes\n\n";
+        for (const commit of entry.changes.other) {
+            changelog += formatCommitLine(commit, options) + "\n";
+        }
+        changelog += "\n";
+    }
+    return changelog;
+}
+/**
+ * Format a single commit line
+ */
+function formatCommitLine(commit, options) {
+    let line = "- ";
+    // Add scope if available and enabled
+    if (options.includeScopes && commit.scope) {
+        line += `**${commit.scope}**: `;
+    }
+    // Add subject
+    line += commit.subject;
+    // Add hash if enabled
+    if (options.includeCommitHashes) {
+        line += ` (${commit.hash.substring(0, 7)})`;
+    }
+    return line;
+}
+/** Update or create a changelog file for a module. */
+export async function updateChangelogFile(moduleResult, changelogContent, repoRoot) {
+    const changelogPath = join(repoRoot, moduleResult.path, "CHANGELOG.md");
+    try {
+        // Try to read existing changelog
+        const existingContent = await fs.readFile(changelogPath, "utf8");
+        // Insert new content after the first heading
+        const lines = existingContent.split("\n");
+        let insertIndex = 0;
+        // Find the first ## heading or the end of initial content
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].startsWith("## ")) {
+                insertIndex = i;
+                break;
+            }
+            if (i === 0 && lines[i].startsWith("# ")) {
+                // Skip the main heading
+                continue;
+            }
+        }
+        // Insert the new changelog entry
+        const beforeInsert = lines.slice(0, insertIndex);
+        const afterInsert = lines.slice(insertIndex);
+        const updatedContent = [
+            ...beforeInsert,
+            changelogContent.trim(),
+            "",
+            ...afterInsert,
+        ].join("\n");
+        await fs.writeFile(changelogPath, updatedContent, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            "code" in error &&
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            error.code === "ENOENT") {
+            // Create new changelog file
+            const moduleName = moduleResult.id === "root" ? "Root Module" : moduleResult.id;
+            const newContent = `# Changelog - ${moduleName}\n\n${changelogContent}`;
+            await fs.writeFile(changelogPath, newContent, "utf8");
+        }
+        else {
+            throw error;
+        }
+    }
+    return changelogPath;
+}
+/** Generate changelog for multiple modules. */
+export async function generateChangelogsForModules(moduleResults, getCommitsForModule, repoRoot, options) {
+    const changelogPaths = [];
+    for (const moduleResult of moduleResults) {
+        const commits = await getCommitsForModule(moduleResult.id);
+        const changelogContent = await generateChangelog(moduleResult, commits, options);
+        const changelogPath = await updateChangelogFile(moduleResult, changelogContent, repoRoot);
+        changelogPaths.push(changelogPath);
+    }
+    return changelogPaths;
+}
+/** Generate a root changelog that summarizes all module changes. */
+export async function generateRootChangelog(moduleResults, repoRoot) {
+    const rootChangelogPath = join(repoRoot, "CHANGELOG.md");
+    const date = new Date().toISOString().split("T")[0];
+    let content = `## ${date}\n\n`;
+    if (moduleResults.length === 0) {
+        content += "No changes in this release.\n\n";
+    }
+    else {
+        content += "### Module Updates\n\n";
+        for (const moduleResult of moduleResults) {
+            const fromVersion = moduleResult.from;
+            const toVersion = moduleResult.to;
+            const moduleName = moduleResult.id === "root" ? "Root" : moduleResult.id;
+            content += `- **${moduleName}**: ${fromVersion} → ${toVersion}\n`;
+        }
+        content += "\n";
+    }
+    try {
+        const existingContent = await fs.readFile(rootChangelogPath, "utf8");
+        const lines = existingContent.split("\n");
+        // Find insertion point (after main heading)
+        let insertIndex = 0;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].startsWith("## ") && i > 0) {
+                insertIndex = i;
+                break;
+            }
+        }
+        const beforeInsert = lines.slice(0, insertIndex);
+        const afterInsert = lines.slice(insertIndex);
+        const updatedContent = [
+            ...beforeInsert,
+            content.trim(),
+            "",
+            ...afterInsert,
+        ].join("\n");
+        await fs.writeFile(rootChangelogPath, updatedContent, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            "code" in error &&
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            error.code === "ENOENT") {
+            const newContent = `# Changelog\n\n${content}`;
+            await fs.writeFile(rootChangelogPath, newContent, "utf8");
+        }
+        else {
+            throw error;
+        }
+    }
+    return rootChangelogPath;
+}

package/dist/config/index.d.ts

@@ -0,0 +1,122 @@
+import { z } from "zod";
+import { BumpType } from "../semver/index.js";
+/**
+ * Zod schema for DependencyRules configuration.
+ * Validates that dependency cascade rules use valid bump types.
+ */
+declare const dependencyRulesSchema: z.ZodObject<{
+    onMajorOfDependency: z.ZodEnum<{
+        major: "major";
+        minor: "minor";
+        patch: "patch";
+        none: "none";
+    }>;
+    onMinorOfDependency: z.ZodEnum<{
+        major: "major";
+        minor: "minor";
+        patch: "patch";
+        none: "none";
+    }>;
+    onPatchOfDependency: z.ZodEnum<{
+        major: "major";
+        minor: "minor";
+        patch: "patch";
+        none: "none";
+    }>;
+}, z.core.$strip>;
+/**
+ * Zod schema for NodeJSConfig configuration.
+ * Validates Node.js-specific settings.
+ */
+declare const nodeJSConfigSchema: z.ZodObject<{
+    versionSource: z.ZodArray<z.ZodLiteral<"package.json">>;
+    updatePackageLock: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Zod schema for the main Config object.
+ * This schema is used by ConfigurationValidator to ensure type-safe
+ * configuration with detailed error messages for invalid configurations.
+ */
+export declare const configSchema: z.ZodObject<{
+    defaultBump: z.ZodEnum<{
+        major: "major";
+        minor: "minor";
+        patch: "patch";
+        none: "none";
+    }>;
+    commitTypes: z.ZodRecord<z.ZodString, z.ZodEnum<{
+        major: "major";
+        minor: "minor";
+        patch: "patch";
+        none: "none";
+        ignore: "ignore";
+    }>>;
+    dependencyRules: z.ZodObject<{
+        onMajorOfDependency: z.ZodEnum<{
+            major: "major";
+            minor: "minor";
+            patch: "patch";
+            none: "none";
+        }>;
+        onMinorOfDependency: z.ZodEnum<{
+            major: "major";
+            minor: "minor";
+            patch: "patch";
+            none: "none";
+        }>;
+        onPatchOfDependency: z.ZodEnum<{
+            major: "major";
+            minor: "minor";
+            patch: "patch";
+            none: "none";
+        }>;
+    }, z.core.$strip>;
+    nodejs: z.ZodOptional<z.ZodObject<{
+        versionSource: z.ZodArray<z.ZodLiteral<"package.json">>;
+        updatePackageLock: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Configuration for μVERSE version bumping behavior.
+ * Controls commit type handling, dependency cascade rules, and adapter-specific settings.
+ */
+export type Config = z.infer<typeof configSchema>;
+/**
+ * Rules for propagating version changes through dependency relationships.
+ * Defines how a module should be bumped when its dependencies change.
+ */
+export type DependencyRules = z.infer<typeof dependencyRulesSchema>;
+/**
+ * Configuration for Node.js/npm projects.
+ */
+export type NodeJSConfig = z.infer<typeof nodeJSConfigSchema>;
+/**
+ * Default μVERSE configuration following Conventional Commits specification.
+ * Maps common commit types to semantic version bumps and defines dependency cascade rules.
+ */
+export declare const DEFAULT_CONFIG: Config;
+/**
+ * Determines the bump type for a commit based on its type and breaking change flag.
+ * @param commitType - The Conventional Commit type (e.g., 'feat', 'fix', 'chore')
+ * @param isBreaking - Whether the commit contains breaking changes
+ * @param config - Configuration containing commit type mappings
+ * @returns The bump type to apply ('major', 'minor', 'patch', or 'none')
+ */
+export declare function getBumpTypeForCommit(commitType: string, isBreaking: boolean, config: Config): BumpType;
+/**
+ * Determines how a module should be bumped when one of its dependencies changes.
+ * Uses dependency cascade rules from configuration to propagate version changes.
+ * @param dependencyBumpType - The bump type applied to the dependency
+ * @param config - Configuration containing dependency cascade rules
+ * @returns The bump type to apply to the dependent module
+ */
+export declare function getDependencyBumpType(dependencyBumpType: BumpType, config: Config): BumpType;
+/**
+ * Retrieves adapter-specific configuration from the main config object.
+ * @param config - The main configuration object
+ * @param adapterName - The name of the adapter configuration to retrieve
+ * @returns The adapter-specific configuration, or undefined if not present
+ */
+export declare function getAdapterConfig<T extends keyof Config>(config: Config, adapterName: T): Config[T];
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAoB9C;;;GAGG;AACH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;iBAIzB,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,kBAAkB;;;iBAGtB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKvB,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,MAmB5B,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,OAAO,EACnB,MAAM,EAAE,MAAM,GACb,QAAQ,CAYV;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,kBAAkB,EAAE,QAAQ,EAC5B,MAAM,EAAE,MAAM,GACb,QAAQ,CAaV;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,MAAM,EACrD,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,CAAC,GACb,MAAM,CAAC,CAAC,CAAC,CAEX"}

package/dist/config/index.js

@@ -0,0 +1,115 @@
+import { z } from "zod";
+/**
+ * Zod schema for BumpType values.
+ * Used for validation in configuration files.
+ */
+const bumpTypeSchema = z.enum(["major", "minor", "patch", "none"]);
+/**
+ * Zod schema for BumpType or 'ignore' values.
+ * Used for commit type mappings where 'ignore' is allowed.
+ */
+const bumpTypeOrIgnoreSchema = z.enum([
+    "major",
+    "minor",
+    "patch",
+    "none",
+    "ignore",
+]);
+/**
+ * Zod schema for DependencyRules configuration.
+ * Validates that dependency cascade rules use valid bump types.
+ */
+const dependencyRulesSchema = z.object({
+    onMajorOfDependency: bumpTypeSchema,
+    onMinorOfDependency: bumpTypeSchema,
+    onPatchOfDependency: bumpTypeSchema,
+});
+/**
+ * Zod schema for NodeJSConfig configuration.
+ * Validates Node.js-specific settings.
+ */
+const nodeJSConfigSchema = z.object({
+    versionSource: z.array(z.literal("package.json")),
+    updatePackageLock: z.boolean(),
+});
+/**
+ * Zod schema for the main Config object.
+ * This schema is used by ConfigurationValidator to ensure type-safe
+ * configuration with detailed error messages for invalid configurations.
+ */
+export const configSchema = z.object({
+    defaultBump: bumpTypeSchema,
+    commitTypes: z.record(z.string(), bumpTypeOrIgnoreSchema),
+    dependencyRules: dependencyRulesSchema,
+    nodejs: nodeJSConfigSchema.optional(),
+});
+/**
+ * Default μVERSE configuration following Conventional Commits specification.
+ * Maps common commit types to semantic version bumps and defines dependency cascade rules.
+ */
+export const DEFAULT_CONFIG = {
+    defaultBump: "patch",
+    commitTypes: {
+        feat: "minor",
+        fix: "patch",
+        perf: "patch",
+        refactor: "patch",
+        docs: "ignore",
+        test: "ignore",
+        chore: "ignore",
+        style: "ignore",
+        ci: "ignore",
+        build: "ignore",
+    },
+    dependencyRules: {
+        onMajorOfDependency: "major",
+        onMinorOfDependency: "minor",
+        onPatchOfDependency: "patch",
+    },
+};
+/**
+ * Determines the bump type for a commit based on its type and breaking change flag.
+ * @param commitType - The Conventional Commit type (e.g., 'feat', 'fix', 'chore')
+ * @param isBreaking - Whether the commit contains breaking changes
+ * @param config - Configuration containing commit type mappings
+ * @returns The bump type to apply ('major', 'minor', 'patch', or 'none')
+ */
+export function getBumpTypeForCommit(commitType, isBreaking, config) {
+    if (isBreaking) {
+        return "major";
+    }
+    const configuredBump = config.commitTypes[commitType];
+    if (configuredBump === "ignore") {
+        return "none";
+    }
+    return configuredBump || config.defaultBump;
+}
+/**
+ * Determines how a module should be bumped when one of its dependencies changes.
+ * Uses dependency cascade rules from configuration to propagate version changes.
+ * @param dependencyBumpType - The bump type applied to the dependency
+ * @param config - Configuration containing dependency cascade rules
+ * @returns The bump type to apply to the dependent module
+ */
+export function getDependencyBumpType(dependencyBumpType, config) {
+    const rules = config.dependencyRules;
+    switch (dependencyBumpType) {
+        case "major":
+            return rules.onMajorOfDependency;
+        case "minor":
+            return rules.onMinorOfDependency;
+        case "patch":
+            return rules.onPatchOfDependency;
+        default:
+            return "none";
+    }
+}
+/**
+ * Retrieves adapter-specific configuration from the main config object.
+ * @param config - The main configuration object
+ * @param adapterName - The name of the adapter configuration to retrieve
+ * @returns The adapter-specific configuration, or undefined if not present
+ */
+export function getAdapterConfig(config, adapterName) {
+    return config[adapterName];
+}

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

@@ -0,0 +1,12 @@
+import { AdapterIdentifierRegistry } from "../services/adapter-identifier-registry.js";
+/**
+ * Creates and configures the global adapter identifier registry.
+ *
+ * @returns Configured {@link AdapterIdentifierRegistry} with all available adapters
+ *
+ * @remarks
+ * Central point for registering all supported project adapters.
+ * To add a new adapter, implement {@link AdapterIdentifier} and add it to the array.
+ */
+export declare function createAdapterIdentifierRegistry(): AdapterIdentifierRegistry;
+//# sourceMappingURL=adapter-identifier-registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-identifier-registry.d.ts","sourceRoot":"","sources":["../../src/factories/adapter-identifier-registry.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AAEvF;;;;;;;;GAQG;AACH,wBAAgB,+BAA+B,IAAI,yBAAyB,CAc3E"}

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

@@ -0,0 +1,24 @@
+import { GradleAdapterIdentifier } from "../adapters/gradle/services/gradle-adapter-identifier.js";
+import { AdapterIdentifierRegistry } from "../services/adapter-identifier-registry.js";
+/**
+ * Creates and configures the global adapter identifier registry.
+ *
+ * @returns Configured {@link AdapterIdentifierRegistry} with all available adapters
+ *
+ * @remarks
+ * Central point for registering all supported project adapters.
+ * To add a new adapter, implement {@link AdapterIdentifier} and add it to the array.
+ */
+export function createAdapterIdentifierRegistry() {
+    // Array of all registered adapter identifiers
+    // Order matters: first matching adapter is selected during auto-detection
+    const identifiers = [
+        new GradleAdapterIdentifier(),
+        // Add future adapter identifiers here as they are implemented:
+        // new MavenAdapterIdentifier(),
+        // new NodeJSAdapterIdentifier(),
+        // new PythonAdapterIdentifier(),
+    ];
+    // Create and return the registry with all registered identifiers
+    return new AdapterIdentifierRegistry(identifiers);
+}

package/dist/factories/module-system-factory.d.ts

@@ -0,0 +1,10 @@
+import { ModuleSystemFactory } from "../services/module-system-factory.js";
+/**
+ * Creates the appropriate module system factory for a given adapter.
+ * @param adapterName - The identifier of the build system adapter (e.g., 'gradle', 'maven', 'npm')
+ * @param repoRoot - The absolute path to the repository root directory
+ * @returns A ModuleSystemFactory instance configured for the specified adapter
+ * @throws {Error} If the adapter name is not recognized or supported
+ */
+export declare function createModuleSystemFactory(adapterName: string, repoRoot: string): ModuleSystemFactory;
+//# sourceMappingURL=module-system-factory.d.ts.map

package/dist/factories/module-system-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-system-factory.d.ts","sourceRoot":"","sources":["../../src/factories/module-system-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAI3E;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,GACf,mBAAmB,CASrB"}

package/dist/factories/module-system-factory.js

@@ -0,0 +1,18 @@
+import { GradleModuleSystemFactory } from "../adapters/gradle/services/gradle-module-system-factory.js";
+import { GRADLE_ID } from "../adapters/gradle/constants.js";
+/**
+ * Creates the appropriate module system factory for a given adapter.
+ * @param adapterName - The identifier of the build system adapter (e.g., 'gradle', 'maven', 'npm')
+ * @param repoRoot - The absolute path to the repository root directory
+ * @returns A ModuleSystemFactory instance configured for the specified adapter
+ * @throws {Error} If the adapter name is not recognized or supported
+ */
+export function createModuleSystemFactory(adapterName, repoRoot) {
+    // Normalize adapter name to lowercase for case-insensitive matching
+    switch (adapterName.toLowerCase()) {
+        case GRADLE_ID:
+            return new GradleModuleSystemFactory(repoRoot);
+        default:
+            throw new Error(`Unsupported adapter: ${adapterName}`);
+    }
+}