@muverse/core 0.1.0

package/README.md

@@ -0,0 +1,22 @@
+# @muverse/core
+
+Core business logic for μVERSE — independent of GitHub Actions.
+
+Build
+
+```bash
+npm run -w packages/core build
+```
+
+Test
+
+```bash
+npm run -w packages/core test
+```
+
+Publish to npm
+
+```bash
+# ensure dist is built
+npm publish --workspace packages/core --access public
+```

package/dist/adapters/gradle/constants.d.ts

@@ -0,0 +1,13 @@
+/** Standard filename for Gradle project properties file ('gradle.properties'). */
+export declare const GRADLE_PROPERTIES_FILE = "gradle.properties";
+/** Standard filename for Gradle build script using Groovy DSL ('build.gradle'). */
+export declare const GRADLE_BUILD_FILE = "build.gradle";
+/** Standard filename for Gradle build script using Kotlin DSL ('build.gradle.kts'). */
+export declare const GRADLE_BUILD_KTS_FILE = "build.gradle.kts";
+/** Standard filename for Gradle settings file using Groovy DSL ('settings.gradle'). */
+export declare const GRADLE_SETTINGS_FILE = "settings.gradle";
+/** Standard filename for Gradle settings file using Kotlin DSL ('settings.gradle.kts'). */
+export declare const GRADLE_SETTINGS_KTS_FILE = "settings.gradle.kts";
+/** Unique identifier for the Gradle adapter ('gradle'). */
+export declare const GRADLE_ID = "gradle";
+//# sourceMappingURL=constants.d.ts.map

package/dist/adapters/gradle/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/adapters/gradle/constants.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,eAAO,MAAM,sBAAsB,sBAAsB,CAAC;AAE1D,mFAAmF;AACnF,eAAO,MAAM,iBAAiB,iBAAiB,CAAC;AAEhD,uFAAuF;AACvF,eAAO,MAAM,qBAAqB,qBAAqB,CAAC;AAExD,uFAAuF;AACvF,eAAO,MAAM,oBAAoB,oBAAoB,CAAC;AAEtD,2FAA2F;AAC3F,eAAO,MAAM,wBAAwB,wBAAwB,CAAC;AAE9D,2DAA2D;AAC3D,eAAO,MAAM,SAAS,WAAW,CAAC"}

package/dist/adapters/gradle/constants.js

@@ -0,0 +1,12 @@
+/** Standard filename for Gradle project properties file ('gradle.properties'). */
+export const GRADLE_PROPERTIES_FILE = 'gradle.properties';
+/** Standard filename for Gradle build script using Groovy DSL ('build.gradle'). */
+export const GRADLE_BUILD_FILE = 'build.gradle';
+/** Standard filename for Gradle build script using Kotlin DSL ('build.gradle.kts'). */
+export const GRADLE_BUILD_KTS_FILE = 'build.gradle.kts';
+/** Standard filename for Gradle settings file using Groovy DSL ('settings.gradle'). */
+export const GRADLE_SETTINGS_FILE = 'settings.gradle';
+/** Standard filename for Gradle settings file using Kotlin DSL ('settings.gradle.kts'). */
+export const GRADLE_SETTINGS_KTS_FILE = 'settings.gradle.kts';
+/** Unique identifier for the Gradle adapter ('gradle'). */
+export const GRADLE_ID = 'gradle';

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

@@ -0,0 +1,18 @@
+import { ProjectInformation, RawProjectInformation } from '../project-information.js';
+/**
+ * Executes Gradle to collect raw project structure information.
+ * Runs gradlew with init script to output JSON containing module hierarchy, versions, and dependencies.
+ * @param projectRoot - Absolute path to the Gradle project root directory
+ * @returns Promise resolving to raw project information as JSON
+ * @throws {Error} If initialization script not found or Gradle execution fails
+ */
+export declare function getRawProjectInformation(projectRoot: string): Promise<RawProjectInformation>;
+/**
+ * Transforms raw project information into structured, queryable format.
+ * Normalizes modules, identifies root, parses versions, and maps dependencies.
+ * @param projectInformation - Raw project information from Gradle
+ * @returns Structured ProjectInformation with normalized data
+ * @throws {Error} If no root module found in hierarchy
+ */
+export declare function getProjectInformation(projectInformation: RawProjectInformation): ProjectInformation;
+//# sourceMappingURL=gradle-project-information.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gradle-project-information.d.ts","sourceRoot":"","sources":["../../../src/adapters/gradle/gradle-project-information.ts"],"names":[],"mappings":"AAGA,OAAO,EAAU,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAgB9F;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAsClG;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,kBAAkB,EAAE,qBAAqB,GAAG,kBAAkB,CAuCnG"}

package/dist/adapters/gradle/gradle-project-information.js

@@ -0,0 +1,93 @@
+import path, { join } from 'path';
+import { createInitialVersion, parseSemVer } from '../../semver/index.js';
+import { exists } from '../../utils/file.js';
+import { fileURLToPath } from 'url';
+import { execa } from 'execa';
+/**
+ * Name of the Gradle wrapper script file.
+ * Ensures consistent builds without requiring pre-installed Gradle.
+ */
+const GRADLE_WRAPPER = 'gradlew';
+/**
+ * Relative path to the Gradle initialization script within the action.
+ * Injected into Gradle to collect project structure information as JSON.
+ */
+const GRADLE_INIT_SCRIPT = './init-project-information.gradle.kts';
+/**
+ * Executes Gradle to collect raw project structure information.
+ * Runs gradlew with init script to output JSON containing module hierarchy, versions, and dependencies.
+ * @param projectRoot - Absolute path to the Gradle project root directory
+ * @returns Promise resolving to raw project information as JSON
+ * @throws {Error} If initialization script not found or Gradle execution fails
+ */
+export async function getRawProjectInformation(projectRoot) {
+    const gradlew = join(projectRoot, GRADLE_WRAPPER);
+    const dirname = path.dirname(fileURLToPath(import.meta.url));
+    const initScriptPath = join(dirname, GRADLE_INIT_SCRIPT);
+    // Check if init script exists
+    const scriptExists = await exists(initScriptPath);
+    if (!scriptExists) {
+        throw new Error(`Init script not found at ${initScriptPath}. ` +
+            `Please create the ${GRADLE_INIT_SCRIPT} file.`);
+    }
+    // Prepare Gradle command arguments
+    const args = [
+        '--quiet', // Suppress non-error output for clean JSON
+        '--console=plain', // Disable ANSI formatting
+        '--init-script', // Inject initialization script
+        initScriptPath,
+        'structure' // Custom task that outputs project structure
+    ];
+    // Execute Gradle wrapper with the prepared arguments
+    const result = await execa(gradlew, args, {
+        cwd: projectRoot, // Run from project root
+        reject: false // Handle non-zero exit codes ourselves
+    });
+    // Check for Gradle execution failure
+    if (result.exitCode !== 0) {
+        throw new Error(`Gradle command failed with exit code ${result.exitCode}: ${result.stderr}`);
+    }
+    // Parse JSON output from Gradle
+    return JSON.parse(result.stdout.trim() || '{}');
+}
+/**
+ * Transforms raw project information into structured, queryable format.
+ * Normalizes modules, identifies root, parses versions, and maps dependencies.
+ * @param projectInformation - Raw project information from Gradle
+ * @returns Structured ProjectInformation with normalized data
+ * @throws {Error} If no root module found in hierarchy
+ */
+export function getProjectInformation(projectInformation) {
+    const moduleIds = Object.keys(projectInformation);
+    const modules = new Map();
+    // Find root module by looking for the one with type 'root'
+    let rootModule;
+    for (const [moduleId, module] of Object.entries(projectInformation)) {
+        if (module.type === 'root') {
+            rootModule = moduleId;
+        }
+        // Create normalized Module object
+        modules.set(moduleId, {
+            id: moduleId,
+            name: module.name,
+            path: module.path,
+            type: module.type,
+            affectedModules: new Set(module.affectedModules),
+            // Parse version if present, otherwise create initial version
+            version: module.version === undefined ?
+                createInitialVersion() :
+                parseSemVer(module.version),
+            declaredVersion: module.declaredVersion,
+        });
+    }
+    // Validate that a root module was found
+    if (!rootModule) {
+        throw new Error('No root module found in hierarchy. ' +
+            'Every project hierarchy must contain exactly one module with type "root".');
+    }
+    return {
+        moduleIds,
+        modules,
+        rootModule
+    };
+}

package/dist/adapters/gradle/gradle-properties.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Converts a gradle.properties version property name to a Gradle module ID.
+ * @param propertyName - Version property name from gradle.properties
+ * @returns Corresponding Gradle module ID
+ */
+export declare function versionPropertyNameToModuleId(propertyName: string): string;
+/**
+ * Converts a Gradle module ID to a gradle.properties version property name.
+ * Uses only the last component of the module path (e.g., ':lib:core' → 'core.version').
+ * @param moduleId - Gradle module ID (e.g., ':', ':app', ':lib:core')
+ * @returns Corresponding property name for gradle.properties
+ * @throws {Error} If the module ID is invalid or cannot be parsed
+ */
+export declare function moduleIdToVersionPropertyName(moduleId: string): string;
+//# sourceMappingURL=gradle-properties.d.ts.map

package/dist/adapters/gradle/gradle-properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradle-properties.d.ts","sourceRoot":"","sources":["../../../src/adapters/gradle/gradle-properties.ts"],"names":[],"mappings":"AAeA;;;;GAIG;AACH,wBAAgB,6BAA6B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAW1E;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAgBtE"}

package/dist/adapters/gradle/gradle-properties.js

@@ -0,0 +1,46 @@
+/** Gradle module identifier for the root project (':'). */
+const ROOT_MODULE_ID = ':';
+/** Property name for version configuration in gradle.properties ('version'). */
+const VERSION = 'version';
+/** Separator character used in Gradle module identifiers (':'). */
+const MODULE_SEPARATOR = ':';
+/** Separator character used in gradle.properties property names ('.'). */
+const DOT_SEPARATOR = '.';
+/** Regular expression to match and remove the '.version' suffix. */
+const VERSION_REGEX = /\.version$/;
+/**
+ * Converts a gradle.properties version property name to a Gradle module ID.
+ * @param propertyName - Version property name from gradle.properties
+ * @returns Corresponding Gradle module ID
+ */
+export function versionPropertyNameToModuleId(propertyName) {
+    // Handle root project special case
+    if (propertyName === VERSION) {
+        return ROOT_MODULE_ID;
+    }
+    // Remove '.version' suffix
+    const nameWithoutSuffix = propertyName.replace(VERSION_REGEX, '');
+    // Convert dot-separated to colon-separated module path: "x.y" -> ":x:y"
+    return `${ROOT_MODULE_ID}${nameWithoutSuffix.replaceAll(DOT_SEPARATOR, MODULE_SEPARATOR)}`;
+}
+/**
+ * Converts a Gradle module ID to a gradle.properties version property name.
+ * Uses only the last component of the module path (e.g., ':lib:core' → 'core.version').
+ * @param moduleId - Gradle module ID (e.g., ':', ':app', ':lib:core')
+ * @returns Corresponding property name for gradle.properties
+ * @throws {Error} If the module ID is invalid or cannot be parsed
+ */
+export function moduleIdToVersionPropertyName(moduleId) {
+    // Handle root project special case
+    if (moduleId === ROOT_MODULE_ID) {
+        return VERSION;
+    }
+    // Split by module separator and get the last component (module name)
+    const name = moduleId.split(MODULE_SEPARATOR).at(-1);
+    // Validate that we got a valid module name
+    if (!name) {
+        throw new Error(`Invalid module ID: ${moduleId}`);
+    }
+    // Return property name: {name}.version
+    return `${name}.${VERSION}`;
+}

package/dist/adapters/gradle/init-project-information.gradle.kts

@@ -0,0 +1,143 @@
+import groovy.json.JsonOutput
+import groovy.json.JsonGenerator
+
+/**
+ * Computes the qualified property name for a project's version in gradle.properties.
+ * Returns "version" for root, "{name}.version" for subprojects.
+ */
+fun Project.qualifiedVersionProperty(): String {
+    val name = if (name.contains(":")) name.split(':').last() else ""
+    return if (name.isEmpty()) "version" else "${name}.version"
+}
+
+gradle.rootProject {
+    /**
+     * Collects and outputs project structure information as JSON.
+     * Includes module hierarchy, paths, versions, and affected modules.
+     */
+    tasks.register("printProjectInformation") {
+        group = "help"
+        description = "Shows which subprojects are affected by changes (hierarchy + direct dependencies)."
+
+        // Capture hierarchy data at configuration time
+        val hierarchyDepsProvider = provider {
+            val hierarchyEdges = linkedMapOf<String, Set<String>>()
+
+            gradle.rootProject.allprojects.forEach { project ->
+                val affectedChildren = mutableSetOf<String>()
+
+                // Recursively collect all subprojects
+                fun collectSubprojects(parent: org.gradle.api.Project) {
+                    parent.subprojects.forEach { child ->
+                        affectedChildren.add(child.path)
+                        collectSubprojects(child)
+                    }
+                }
+
+                collectSubprojects(project)
+                hierarchyEdges[project.path] = affectedChildren.toSet()
+            }
+            hierarchyEdges
+        }
+
+        // Capture direct project dependencies at configuration time
+        val dependencyDepsProvider = provider {
+            val dependencyEdges = linkedMapOf<String, Set<String>>()
+
+            gradle.rootProject.allprojects.forEach { project ->
+                val directDeps = mutableSetOf<String>()
+
+                project.configurations.forEach { config ->
+                    // Check regular dependencies
+                    config.dependencies.forEach { dep ->
+                        if (dep is ProjectDependency) {
+                            directDeps.add(dep.dependencyProject.path)
+                        }
+                    }
+
+                    // Check dependency constraints (platform/BOM imports)
+                    config.dependencyConstraints.forEach { constraint ->
+                        // Constraints reference projects by group:name, need to resolve to project path
+                        val constraintProject = gradle.rootProject.allprojects.find { proj ->
+                            proj.group.toString() == constraint.group && proj.name == constraint.name
+                        }
+                        constraintProject?.let { directDeps.add(it.path) }
+                    }
+                }
+
+                dependencyEdges[project.path] = directDeps.toSet()
+            }
+            dependencyEdges
+        }
+
+        // Capture project metadata at configuration time
+        val projectDataProvider = provider {
+            val projectData = linkedMapOf<String, Map<String, Any?>>()
+
+            gradle.rootProject.allprojects.forEach { project ->
+                val relativePath = gradle.rootProject.projectDir.toPath().relativize(project.projectDir.toPath()).toString()
+                val path = if (relativePath.isEmpty()) "." else relativePath
+                val version = if (project.version == "unspecified") null else project.version
+                val type = if (project == gradle.rootProject) "root" else "module"
+                val versionPropertyKey = project.qualifiedVersionProperty()
+                val versionFromProperty = project.findProperty(versionPropertyKey) as? String
+
+                projectData[project.path] = mapOf(
+                    "path" to path,
+                    "version" to version,
+                    "type" to type,
+                    "name" to project.name,
+                    "declaredVersion" to (versionFromProperty != null)
+                )
+            }
+            projectData
+        }
+
+        doLast {
+            val hierarchyMap = hierarchyDepsProvider.get()
+            val dependencyMap = dependencyDepsProvider.get()
+            val projectDataMap = projectDataProvider.get()
+
+            // Calculate directly affected modules only
+            val result = projectDataMap.keys.sorted().associateWith { projectPath ->
+                val projectInfo = projectDataMap.getValue(projectPath)
+                val affectedModules = mutableSetOf<String>()
+
+                // Add hierarchy children
+                hierarchyMap[projectPath]?.let { affectedModules.addAll(it) }
+
+                // Add projects that directly depend on this one
+                dependencyMap.forEach { (dependent, dependencies) ->
+                    if (projectPath in dependencies) {
+                        affectedModules.add(dependent)
+                    }
+                }
+
+                mapOf(
+                    "path" to projectInfo["path"],
+                    "affectedModules" to affectedModules.toSortedSet(),
+                    "version" to projectInfo["version"],
+                    "type" to projectInfo["type"],
+                    "name" to projectInfo["name"],
+                    "declaredVersion" to projectInfo["declaredVersion"]
+                )
+            }
+
+            val generator = JsonGenerator.Options()
+                .excludeNulls()
+                .build()
+
+            println(JsonOutput.prettyPrint(generator.toJson(result)))
+        }
+    }
+
+    /**
+     * Convenience alias for printProjectInformation task.
+     * Usage: ./gradlew --init-script <path> structure
+     */
+    tasks.register("structure") {
+        group = "help"
+        description = "Show project structure information"
+        dependsOn("printProjectInformation")
+    }
+}

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

@@ -0,0 +1,21 @@
+import { AdapterIdentifier } from '../../../services/adapter-identifier.js';
+/**
+ * Adapter identifier for Gradle-based projects.
+ * Detects Gradle projects by looking for gradle.properties, build.gradle(.kts), or settings.gradle(.kts) files.
+ */
+export declare class GradleAdapterIdentifier implements AdapterIdentifier {
+    /** Metadata describing this Gradle adapter (id: 'gradle', supports snapshots). */
+    readonly metadata: {
+        id: string;
+        capabilities: {
+            supportsSnapshots: boolean;
+        };
+    };
+    /**
+     * Determines whether the specified project is a Gradle project.
+     * @param projectRoot - Absolute path to the project root directory
+     * @returns True if any Gradle-specific file is found in the project root
+     */
+    accept(projectRoot: string): Promise<boolean>;
+}
+//# sourceMappingURL=gradle-adapter-identifier.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gradle-adapter-identifier.d.ts","sourceRoot":"","sources":["../../../../src/adapters/gradle/services/gradle-adapter-identifier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yCAAyC,CAAC;AAe5E;;;GAGG;AACH,qBAAa,uBAAwB,YAAW,iBAAiB;IAC/D,kFAAkF;IAClF,QAAQ,CAAC,QAAQ;;;;;MAKf;IAEF;;;;OAIG;IACG,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAkBpD"}

package/dist/adapters/gradle/services/gradle-adapter-identifier.js

@@ -0,0 +1,44 @@
+import * as fs from 'fs/promises';
+import { GRADLE_PROPERTIES_FILE, GRADLE_BUILD_FILE, GRADLE_BUILD_KTS_FILE, GRADLE_SETTINGS_FILE, GRADLE_SETTINGS_KTS_FILE, GRADLE_ID } from '../constants.js';
+import { exists } from '../../../utils/file.js';
+import { logger } from '../../../utils/logger.js';
+/** List of file names that indicate a Gradle project. */
+const GRADLE_FILES = [
+    GRADLE_PROPERTIES_FILE,
+    GRADLE_BUILD_FILE,
+    GRADLE_BUILD_KTS_FILE,
+    GRADLE_SETTINGS_FILE,
+    GRADLE_SETTINGS_KTS_FILE
+];
+/**
+ * Adapter identifier for Gradle-based projects.
+ * Detects Gradle projects by looking for gradle.properties, build.gradle(.kts), or settings.gradle(.kts) files.
+ */
+export class GradleAdapterIdentifier {
+    /** Metadata describing this Gradle adapter (id: 'gradle', supports snapshots). */
+    metadata = {
+        id: GRADLE_ID,
+        capabilities: {
+            supportsSnapshots: true
+        }
+    };
+    /**
+     * Determines whether the specified project is a Gradle project.
+     * @param projectRoot - Absolute path to the project root directory
+     * @returns True if any Gradle-specific file is found in the project root
+     */
+    async accept(projectRoot) {
+        // Check if project root directory exists
+        const projectRootExists = await exists(projectRoot);
+        if (!projectRootExists) {
+            // Log for debugging and return false immediately
+            logger.debug(`Project root does not exist: ${projectRoot}`);
+            return false;
+        }
+        // Read directory contents (only top-level files)
+        const files = await fs.readdir(projectRoot);
+        // Check if any known Gradle file is present in the directory
+        const hasGradleFile = GRADLE_FILES.some(file => files.includes(file));
+        return hasGradleFile;
+    }
+}

package/dist/adapters/gradle/services/gradle-module-detector.d.ts

@@ -0,0 +1,18 @@
+import { ModuleDetector } from "../../../services/module-detector.js";
+import { ModuleRegistry } from '../../../services/module-registry.js';
+/**
+ * Module detector for Gradle-based projects.
+ * Executes Gradle to discover all modules and their dependencies, returning a ModuleRegistry.
+ */
+export declare class GradleModuleDetector implements ModuleDetector {
+    readonly repoRoot: string;
+    /** Absolute path to the repository root directory. */
+    constructor(repoRoot: string);
+    /**
+     * Detects and catalogs all modules in the Gradle project.
+     * @returns ModuleRegistry containing all discovered modules and their relationships
+     * @throws {Error} If Gradle execution fails or project information cannot be parsed
+     */
+    detect(): Promise<ModuleRegistry>;
+}
+//# sourceMappingURL=gradle-module-detector.d.ts.map

package/dist/adapters/gradle/services/gradle-module-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradle-module-detector.d.ts","sourceRoot":"","sources":["../../../../src/adapters/gradle/services/gradle-module-detector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAMtE;;;GAGG;AACH,qBAAa,oBAAqB,YAAW,cAAc;IAE7C,QAAQ,CAAC,QAAQ,EAAE,MAAM;IADrC,sDAAsD;gBACjC,QAAQ,EAAE,MAAM;IAErC;;;;OAIG;IACG,MAAM,IAAI,OAAO,CAAC,cAAc,CAAC;CAUxC"}

package/dist/adapters/gradle/services/gradle-module-detector.js

@@ -0,0 +1,26 @@
+import { ModuleRegistry } from '../../../services/module-registry.js';
+import { getRawProjectInformation, getProjectInformation } from '../gradle-project-information.js';
+/**
+ * Module detector for Gradle-based projects.
+ * Executes Gradle to discover all modules and their dependencies, returning a ModuleRegistry.
+ */
+export class GradleModuleDetector {
+    repoRoot;
+    /** Absolute path to the repository root directory. */
+    constructor(repoRoot) {
+        this.repoRoot = repoRoot;
+    }
+    /**
+     * Detects and catalogs all modules in the Gradle project.
+     * @returns ModuleRegistry containing all discovered modules and their relationships
+     * @throws {Error} If Gradle execution fails or project information cannot be parsed
+     */
+    async detect() {
+        // Step 1: Execute Gradle and collect raw project structure data
+        const rawProjectInformation = await getRawProjectInformation(this.repoRoot);
+        // Step 2: Parse and transform raw data into structured module information
+        const projectInformation = getProjectInformation(rawProjectInformation);
+        // Step 3: Create a registry for efficient module access and querying
+        return new ModuleRegistry(projectInformation);
+    }
+}

package/dist/adapters/gradle/services/gradle-module-system-factory.d.ts

@@ -0,0 +1,23 @@
+import { ModuleSystemFactory } from "../../../services/module-system-factory.js";
+import { ModuleDetector } from "../../../services/module-detector.js";
+import { VersionUpdateStrategy } from "../../../services/version-update-strategy.js";
+/**
+ * Factory for creating Gradle-specific module system components.
+ * Creates module detector and version update strategy instances.
+ */
+export declare class GradleModuleSystemFactory implements ModuleSystemFactory {
+    private readonly repoRoot;
+    /** Absolute path to the repository root directory. */
+    constructor(repoRoot: string);
+    /**
+     * Creates a Gradle-specific module detector.
+     * @returns GradleModuleDetector instance configured with the repository root
+     */
+    createDetector(): ModuleDetector;
+    /**
+     * Creates a Gradle-specific version update strategy.
+     * @returns GradleVersionUpdateStrategy instance configured with the repository root
+     */
+    createVersionUpdateStrategy(): VersionUpdateStrategy;
+}
+//# sourceMappingURL=gradle-module-system-factory.d.ts.map

package/dist/adapters/gradle/services/gradle-module-system-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradle-module-system-factory.d.ts","sourceRoot":"","sources":["../../../../src/adapters/gradle/services/gradle-module-system-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AACjF,OAAO,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,8CAA8C,CAAC;AAIrF;;;GAGG;AACH,qBAAa,yBAA0B,YAAW,mBAAmB;IAEvD,OAAO,CAAC,QAAQ,CAAC,QAAQ;IADrC,sDAAsD;gBACzB,QAAQ,EAAE,MAAM;IAE7C;;;OAGG;IACH,cAAc,IAAI,cAAc;IAIhC;;;OAGG;IACH,2BAA2B,IAAI,qBAAqB;CAGrD"}

package/dist/adapters/gradle/services/gradle-module-system-factory.js

@@ -0,0 +1,27 @@
+import { GradleModuleDetector } from './gradle-module-detector.js';
+import { GradleVersionUpdateStrategy } from './gradle-version-update-strategy.js';
+/**
+ * Factory for creating Gradle-specific module system components.
+ * Creates module detector and version update strategy instances.
+ */
+export class GradleModuleSystemFactory {
+    repoRoot;
+    /** Absolute path to the repository root directory. */
+    constructor(repoRoot) {
+        this.repoRoot = repoRoot;
+    }
+    /**
+     * Creates a Gradle-specific module detector.
+     * @returns GradleModuleDetector instance configured with the repository root
+     */
+    createDetector() {
+        return new GradleModuleDetector(this.repoRoot);
+    }
+    /**
+     * Creates a Gradle-specific version update strategy.
+     * @returns GradleVersionUpdateStrategy instance configured with the repository root
+     */
+    createVersionUpdateStrategy() {
+        return new GradleVersionUpdateStrategy(this.repoRoot);
+    }
+}

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

@@ -0,0 +1,21 @@
+import { VersionUpdateStrategy } from "../../../services/version-update-strategy.js";
+/**
+ * Gradle-specific implementation for version update operations.
+ * Updates module versions by modifying gradle.properties file.
+ */
+export declare class GradleVersionUpdateStrategy implements VersionUpdateStrategy {
+    /** Absolute path to the gradle.properties file. */
+    private readonly versionFilePath;
+    /**
+     * Creates a new Gradle version update strategy.
+     * @param repoRoot - Absolute path to the repository root directory
+     */
+    constructor(repoRoot: string);
+    /**
+     * Writes version updates for multiple modules to gradle.properties.
+     * @param moduleVersions - Map of module IDs to new version strings
+     * @throws {Error} If the file cannot be read or written
+     */
+    writeVersionUpdates(moduleVersions: Map<string, string>): Promise<void>;
+}
+//# sourceMappingURL=gradle-version-update-strategy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gradle-version-update-strategy.d.ts","sourceRoot":"","sources":["../../../../src/adapters/gradle/services/gradle-version-update-strategy.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,8CAA8C,CAAC;AAKrF;;;GAGG;AACH,qBAAa,2BAA4B,YAAW,qBAAqB;IACvE,mDAAmD;IACnD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IAEzC;;;OAGG;gBACS,QAAQ,EAAE,MAAM;IAI5B;;;;OAIG;IACG,mBAAmB,CAAC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CAc9E"}

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

@@ -0,0 +1,36 @@
+import { join } from 'path';
+import { moduleIdToVersionPropertyName } from '../gradle-properties.js';
+import { upsertProperties } from '../../../utils/properties.js';
+import { GRADLE_PROPERTIES_FILE } from '../constants.js';
+/**
+ * Gradle-specific implementation for version update operations.
+ * Updates module versions by modifying gradle.properties file.
+ */
+export class GradleVersionUpdateStrategy {
+    /** Absolute path to the gradle.properties file. */
+    versionFilePath;
+    /**
+     * Creates a new Gradle version update strategy.
+     * @param repoRoot - Absolute path to the repository root directory
+     */
+    constructor(repoRoot) {
+        this.versionFilePath = join(repoRoot, GRADLE_PROPERTIES_FILE);
+    }
+    /**
+     * Writes version updates for multiple modules to gradle.properties.
+     * @param moduleVersions - Map of module IDs to new version strings
+     * @throws {Error} If the file cannot be read or written
+     */
+    async writeVersionUpdates(moduleVersions) {
+        // Convert module IDs to property names
+        // Example: ':app' → 'app.version', ':' → 'version'
+        const propertyUpdates = new Map();
+        for (const [moduleId, versionString] of moduleVersions) {
+            const propertyName = moduleIdToVersionPropertyName(moduleId);
+            propertyUpdates.set(propertyName, versionString);
+        }
+        // Write all properties to gradle.properties file in one atomic operation
+        // This ensures consistency and prevents partial updates
+        await upsertProperties(this.versionFilePath, propertyUpdates);
+    }
+}