@versu/plugin-gradle 0.6.0

package/dist/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/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/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/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/gradle-project-information.d.ts

@@ -0,0 +1,19 @@
+import { ProjectInformation, RawProjectInformation } from '@versu/core';
+/**
+ * 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
+ * @param outputFile - Path to output JSON file to be generated
+ * @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, outputFile: 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/gradle-project-information.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradle-project-information.d.ts","sourceRoot":"","sources":["../src/gradle-project-information.ts"],"names":[],"mappings":"AAMA,OAAO,EAA0F,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAqHhK;;;;;;;GAOG;AACH,wBAAsB,wBAAwB,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAyEtH;AA2CD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,kBAAkB,EAAE,qBAAqB,GAAG,kBAAkB,CA6CnG"}

package/dist/gradle-project-information.js

@@ -0,0 +1,232 @@
+import path, { join } from 'path';
+import { fileURLToPath } from 'url';
+import { execa } from 'execa';
+import fs from 'fs/promises';
+import crypto from 'crypto';
+import fg from 'fast-glob';
+import { createInitialVersion, exists, logger, parseProperties, parseSemVer } from '@versu/core';
+/**
+ * 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';
+/**
+ * Finds all Gradle build files recursively under the project root.
+ * Searches for settings.gradle, settings.gradle.kts, build.gradle, and build.gradle.kts files.
+ * @param projectRoot - Absolute path to the Gradle project root directory
+ * @returns Promise resolving to array of relative paths to Gradle build files
+ */
+async function findGradleFiles(projectRoot) {
+    const patterns = [
+        '**/settings.gradle',
+        '**/settings.gradle.kts',
+        '**/build.gradle',
+        '**/build.gradle.kts'
+    ];
+    const files = await fg(patterns, {
+        cwd: projectRoot,
+        absolute: false,
+        ignore: ['**/node_modules/**', '**/build/**', '**/.gradle/**']
+    });
+    // Sort for consistent ordering
+    return files.sort();
+}
+/**
+ * Computes SHA-256 hash of all Gradle build files.
+ * Used to detect changes in project configuration that would invalidate cached information.
+ * @param projectRoot - Absolute path to the Gradle project root directory
+ * @returns Promise resolving to hexadecimal hash string
+ */
+async function computeGradleFilesHash(projectRoot) {
+    const files = await findGradleFiles(projectRoot);
+    const hash = crypto.createHash('sha256');
+    for (const file of files) {
+        const content = await fs.readFile(join(projectRoot, file), 'utf-8');
+        hash.update(file); // Include file path for uniqueness
+        hash.update(content);
+    }
+    return hash.digest('hex');
+}
+/**
+ * Executes the Gradle wrapper script to generate project information.
+ * Runs gradlew with initialization script to create the project-information.json file.
+ * @param projectRoot - Absolute path to the Gradle project root directory
+ * @param outputFile - Path to output JSON file to be generated
+ * @throws {Error} If initialization script not found or Gradle execution fails
+ */
+async function executeGradleScript(projectRoot, outputFile) {
+    logger.info(`⚙️ Executing Gradle to collect project information...`);
+    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
+        `-PprojectInfoOutput=${outputFile}`
+    ];
+    // 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}`);
+    }
+    logger.info(`✅ Gradle project information generated at ${outputFile}.`);
+}
+/**
+ * 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
+ * @param outputFile - Path to output JSON file to be generated
+ * @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, outputFile) {
+    // Step 1: Check if project-information.json exists
+    const fileExists = await exists(outputFile);
+    let data = {};
+    let executeScript = true;
+    // Compute hash of all Gradle build files
+    const currentHash = await computeGradleFilesHash(projectRoot);
+    logger.debug(`🔍 Computed Gradle files hash: ${currentHash}`);
+    if (fileExists) {
+        logger.info(`💾 Cached project information found at ${outputFile}. Validating cache...`);
+        // Step 2: File exists, check cache validity
+        try {
+            const fileContent = await fs.readFile(outputFile, 'utf-8');
+            const cachedData = JSON.parse(fileContent);
+            // Step 2.1: Compare hashes
+            if (cachedData.hash === currentHash) {
+                logger.info(`✅ Cache is valid. Using cached project information.`);
+                // Cache hit - use cached data
+                executeScript = false;
+                data = cachedData.data;
+            }
+            else {
+                logger.debug(`❌ Cache is invalid. Cached hash: ${cachedData.hash}`);
+                logger.info(`🔄 Gradle files changed, regenerating project information...`);
+            }
+            // Cache miss - hash mismatch, need to regenerate
+        }
+        catch (error) {
+            // If there's any error reading/parsing cached file, regenerate
+            logger.warning(`⚠️ Failed to read cached project information: ${error}`);
+        }
+    }
+    if (executeScript) {
+        // Step 3: File doesn't exist or cache is invalid - execute Gradle script
+        const outputFile = join(projectRoot, 'build', 'project-information.json');
+        await executeGradleScript(projectRoot, outputFile);
+        // Verify that the output file was created
+        const fileExistsAfterExec = await exists(outputFile);
+        if (!fileExistsAfterExec) {
+            throw new Error(`Expected output file not found at ${outputFile}. ` +
+                `Ensure that the Gradle init script is correctly generating the project information.`);
+        }
+        // Read the output file content
+        const fileContent = await fs.readFile(outputFile, 'utf-8');
+        // Parse JSON output from Gradle
+        data = JSON.parse(fileContent.trim() || '{}');
+    }
+    // Compute hash and save with cache information
+    const cachedData = {
+        hash: currentHash,
+        data
+    };
+    // Read gradle.properites and add version
+    const projectInformation = await getInformationWithVersions(projectRoot, data);
+    if (executeScript) {
+        // Write back to file with hash for future cache validation
+        const dirname = path.dirname(outputFile);
+        await fs.mkdir(dirname, { recursive: true });
+        await fs.writeFile(outputFile, JSON.stringify(cachedData, null, 2), 'utf-8');
+    }
+    return projectInformation;
+}
+/**
+ * Reads gradle.properties to extract module versions and augment raw project information.
+ * @param projectRoot - Absolute path to the Gradle project root directory
+ * @param projectInformation - Gradle project information without versions
+ * @returns Promise resolving to augmented RawProjectInformation with versions
+ */
+async function getInformationWithVersions(projectRoot, projectInformation) {
+    const gradlePropertiesFile = join(projectRoot, 'gradle.properties');
+    const gradlePropertiesExists = await exists(gradlePropertiesFile);
+    const result = {};
+    let moduleVersions = new Map();
+    if (gradlePropertiesExists) {
+        moduleVersions = await parseProperties(gradlePropertiesFile);
+        for (const [moduleId, module] of Object.entries(projectInformation)) {
+            const version = moduleVersions.get(module.versionProperty);
+            const resultVersion = version ? version : undefined;
+            result[moduleId] = {
+                ...module,
+                version: resultVersion,
+                declaredVersion: resultVersion !== undefined
+            };
+        }
+    }
+    return result;
+}
+/**
+ * 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, rawModule] of Object.entries(projectInformation)) {
+        if (rawModule.type === 'root') {
+            rootModule = moduleId;
+        }
+        // Create normalized Module object
+        const module = {
+            id: moduleId,
+            name: rawModule.name,
+            path: rawModule.path,
+            type: rawModule.type,
+            affectedModules: new Set(rawModule.affectedModules),
+            // Parse version if present, otherwise create initial version
+            version: rawModule.version === undefined ?
+                createInitialVersion() :
+                parseSemVer(rawModule.version),
+            declaredVersion: rawModule.declaredVersion,
+        };
+        if ('versionProperty' in rawModule) {
+            module['versionProperty'] = rawModule.versionProperty;
+        }
+        modules.set(moduleId, module);
+    }
+    // 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/index.d.ts

@@ -0,0 +1,4 @@
+import { PluginContract } from "../../core/dist/plugins/plugin-loader";
+declare const gradlePlugin: PluginContract;
+export default gradlePlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAKvE,QAAA,MAAM,YAAY,EAAE,cAenB,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,18 @@
+import { GradleAdapterIdentifier } from "./services/gradle-adapter-identifier";
+import { GradleModuleSystemFactory } from "./services/gradle-module-system-factory";
+import { AUTHORS, VERSION } from "./utils/version";
+const gradlePlugin = {
+    id: "gradle",
+    name: "Gradle",
+    description: "Adapter plugin for Gradle build system. Provides support for detecting and updating versions in Gradle projects.",
+    version: VERSION,
+    author: AUTHORS,
+    adapters: [
+        {
+            id: "gradle",
+            adapterIdentifier: () => new GradleAdapterIdentifier(),
+            moduleSystemFactory: (repoRoot) => new GradleModuleSystemFactory(repoRoot),
+        },
+    ],
+};
+export default gradlePlugin;

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

@@ -0,0 +1,163 @@
+import groovy.json.JsonOutput
+import groovy.json.JsonGenerator
+
+/**
+ * Retrieves the qualified version property name for the project.
+ * Checks for properties in the order: "<projectName>.version", "<rootProjectName>.version", "version".
+ */
+fun Project.qualifiedVersionProperty(): String {
+    val candidates = listOf("${name}.version", "${rootProject.name}.version", "version")
+    return candidates.first(::hasProperty)
+}
+
+/**
+ * Retrieves the qualified version value for the project.
+ * Uses the qualified version property name to find the property value.
+ */
+fun Project.qualifiedVersion(): String =
+    qualifiedVersionProperty().run(::findProperty) as String
+
+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)."
+        notCompatibleWithConfigurationCache("uses project information at configuration time")
+
+        // 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.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 = relativePath.ifEmpty { "." }
+                val version = if (project.version == "unspecified") null else project.version
+                val type = if (project == gradle.rootProject) "root" else "module"
+                val versionProperty = project.qualifiedVersionProperty()
+                val versionFromProperty = project.qualifiedVersion().takeIf {
+                    it.isNotBlank() && it != "unspecified"
+                }
+
+                projectData[project.path] = mapOf(
+                    "path" to path,
+                    "version" to version,
+                    "type" to type,
+                    "name" to project.name,
+                    "declaredVersion" to (versionFromProperty != null),
+                    "versionProperty" to versionProperty
+                )
+            }
+            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(),
+                    "type" to projectInfo["type"],
+                    "name" to projectInfo["name"],
+                    "versionProperty" to projectInfo["versionProperty"]
+                )
+            }
+
+            val generator = JsonGenerator.Options()
+                .excludeNulls()
+                .build()
+
+            val json = JsonOutput.prettyPrint(generator.toJson(result))
+
+            // Get output path from project property or use default
+            val outputPath = project.findProperty("projectInfoOutput") as? String
+                ?: "${layout.buildDirectory.asFile.get().path}/project-information.json"
+
+            val outputFile = file(outputPath)
+            outputFile.parentFile.mkdirs()
+            outputFile.writeText(json)
+
+            println("Project information written to: ${outputFile.absolutePath}")
+        }
+    }
+
+    /**
+     * 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/services/gradle-adapter-identifier.d.ts

@@ -0,0 +1,21 @@
+import { AdapterIdentifier } from "@versu/core";
+/**
+ * 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/services/gradle-adapter-identifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradle-adapter-identifier.d.ts","sourceRoot":"","sources":["../../src/services/gradle-adapter-identifier.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,iBAAiB,EAAkB,MAAM,aAAa,CAAC;AAWhE;;;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/services/gradle-adapter-identifier.js

@@ -0,0 +1,43 @@
+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, logger } from "@versu/core";
+/** 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/services/gradle-module-detector.d.ts

@@ -0,0 +1,18 @@
+import { ModuleDetector, ModuleRegistry } from "@versu/core";
+/**
+ * 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;
+    readonly outputFile: string;
+    /** Absolute path to the repository root directory. */
+    constructor(repoRoot: string, outputFile: 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/services/gradle-module-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradle-module-detector.d.ts","sourceRoot":"","sources":["../../src/services/gradle-module-detector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAM7D;;;GAGG;AACH,qBAAa,oBAAqB,YAAW,cAAc;IAGvD,QAAQ,CAAC,QAAQ,EAAE,MAAM;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM;IAH7B,sDAAsD;gBAE3C,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM;IAG7B;;;;OAIG;IACG,MAAM,IAAI,OAAO,CAAC,cAAc,CAAC;CAaxC"}

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

@@ -0,0 +1,28 @@
+import { ModuleRegistry } from "@versu/core";
+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;
+    outputFile;
+    /** Absolute path to the repository root directory. */
+    constructor(repoRoot, outputFile) {
+        this.repoRoot = repoRoot;
+        this.outputFile = outputFile;
+    }
+    /**
+     * 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, this.outputFile);
+        // 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/services/gradle-module-system-factory.d.ts

@@ -0,0 +1,23 @@
+import { ModuleDetector, ModuleRegistry, ModuleSystemFactory, VersionUpdateStrategy } from "@versu/core";
+/**
+ * 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.
+     * @param outputFile - Path to the output file for project information
+     * @returns GradleModuleDetector instance configured with the repository root
+     */
+    createDetector(outputFile: string): ModuleDetector;
+    /**
+     * Creates a Gradle-specific version update strategy.
+     * @param moduleRegistry - ModuleRegistry containing all detected modules
+     * @returns GradleVersionUpdateStrategy instance configured with the repository root
+     */
+    createVersionUpdateStrategy(moduleRegistry: ModuleRegistry): VersionUpdateStrategy;
+}
+//# sourceMappingURL=gradle-module-system-factory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gradle-module-system-factory.d.ts","sourceRoot":"","sources":["../../src/services/gradle-module-system-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,cAAc,EACd,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,aAAa,CAAC;AAIrB;;;GAGG;AACH,qBAAa,yBAA0B,YAAW,mBAAmB;IAEvD,OAAO,CAAC,QAAQ,CAAC,QAAQ;IADrC,sDAAsD;gBACzB,QAAQ,EAAE,MAAM;IAE7C;;;;OAIG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc;IAIlD;;;;OAIG;IACH,2BAA2B,CACzB,cAAc,EAAE,cAAc,GAC7B,qBAAqB;CAGzB"}

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

@@ -0,0 +1,29 @@
+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.
+     * @param outputFile - Path to the output file for project information
+     * @returns GradleModuleDetector instance configured with the repository root
+     */
+    createDetector(outputFile) {
+        return new GradleModuleDetector(this.repoRoot, outputFile);
+    }
+    /**
+     * Creates a Gradle-specific version update strategy.
+     * @param moduleRegistry - ModuleRegistry containing all detected modules
+     * @returns GradleVersionUpdateStrategy instance configured with the repository root
+     */
+    createVersionUpdateStrategy(moduleRegistry) {
+        return new GradleVersionUpdateStrategy(this.repoRoot, moduleRegistry);
+    }
+}

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

@@ -0,0 +1,22 @@
+import { ModuleRegistry, VersionUpdateStrategy } from "@versu/core";
+/**
+ * Gradle-specific implementation for version update operations.
+ * Updates module versions by modifying gradle.properties file.
+ */
+export declare class GradleVersionUpdateStrategy implements VersionUpdateStrategy {
+    private readonly moduleRegistry;
+    /** 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, moduleRegistry: ModuleRegistry);
+    /**
+     * 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/services/gradle-version-update-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradle-version-update-strategy.d.ts","sourceRoot":"","sources":["../../src/services/gradle-version-update-strategy.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,cAAc,EAEd,qBAAqB,EACtB,MAAM,aAAa,CAAC;AAErB;;;GAGG;AACH,qBAAa,2BAA4B,YAAW,qBAAqB;IAUrE,OAAO,CAAC,QAAQ,CAAC,cAAc;IATjC,mDAAmD;IACnD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IAEzC;;;OAGG;gBAED,QAAQ,EAAE,MAAM,EACC,cAAc,EAAE,cAAc;IAKjD;;;;OAIG;IACG,mBAAmB,CACvB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAClC,OAAO,CAAC,IAAI,CAAC;CAejB"}

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

@@ -0,0 +1,38 @@
+import { join } from "path";
+import { GRADLE_PROPERTIES_FILE } from "../constants.js";
+import { upsertProperties, } from "@versu/core";
+/**
+ * Gradle-specific implementation for version update operations.
+ * Updates module versions by modifying gradle.properties file.
+ */
+export class GradleVersionUpdateStrategy {
+    moduleRegistry;
+    /** 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, moduleRegistry) {
+        this.moduleRegistry = moduleRegistry;
+        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 module = this.moduleRegistry.getModule(moduleId);
+            const propertyName = module["versionProperty"];
+            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);
+    }
+}

package/dist/utils/version.d.ts

@@ -0,0 +1,4 @@
+export declare const VERSION = "0.6.0";
+export declare const PACKAGE_NAME = "@versu/plugin-gradle";
+export declare const AUTHORS = "tvcsantos";
+//# sourceMappingURL=version.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/utils/version.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO,UAAU,CAAC;AAC/B,eAAO,MAAM,YAAY,yBAAyB,CAAC;AACnD,eAAO,MAAM,OAAO,cAAc,CAAC"}

package/dist/utils/version.js

@@ -0,0 +1,5 @@
+// This file is auto-generated. Do not edit manually.
+// Run 'npm run generate-version' to update this file.
+export const VERSION = "0.6.0";
+export const PACKAGE_NAME = "@versu/plugin-gradle";
+export const AUTHORS = "tvcsantos";

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@versu/plugin-gradle",
+  "version": "0.6.0",
+  "description": "VERSU Gradle Plugin",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "prebuild": "node scripts/generate-version.js",
+    "build": "npm run build:esm",
+    "build:esm": "tsc --project tsconfig.json --outDir dist && npm run copy-assets",
+    "build:cjs": "tsc --project tsconfig.cjs.json --outDir dist && npm run copy-assets",
+    "test": "vitest",
+    "test:coverage": "vitest --coverage",
+    "lint": "eslint src/**/*.ts",
+    "format": "prettier --write src/**/*.ts",
+    "copy-assets": "cpx \"src/init-project-information.gradle.kts\" \"dist/\""
+  },
+  "keywords": [
+    "versu",
+    "plugin",
+    "gradle",
+    "semantic-versioning",
+    "conventional-commits",
+    "version-engine",
+    "dependency-cascade",
+    "monorepo"
+  ],
+  "author": "tvcsantos",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tvcsantos/versu.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tvcsantos/versu/issues"
+  },
+  "homepage": "https://github.com/tvcsantos/versu#readme",
+  "files": [
+    "dist"
+  ],
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "execa": "^9.6.1",
+    "fast-glob": "^3.3.3",
+    "semver": "^7.5.4",
+    "@versu/core": "^0.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.23",
+    "@types/semver": "^7.5.6",
+    "@typescript-eslint/eslint-plugin": "^6.15.0",
+    "@typescript-eslint/parser": "^6.15.0",
+    "@vitest/coverage-v8": "^1.1.0",
+    "cpx": "^1.5.0",
+    "eslint": "^8.56.0",
+    "prettier": "^3.1.1",
+    "typescript": "^5.3.3",
+    "vitest": "^1.1.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}