@versu/core 0.4.0

package/dist/adapters/gradle/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/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,19 @@
+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;
+    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/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;IAAE,QAAQ,CAAC,UAAU,EAAE,MAAM;IADlE,sDAAsD;gBACjC,QAAQ,EAAE,MAAM,EAAW,UAAU,EAAE,MAAM;IAElE;;;;OAIG;IACG,MAAM,IAAI,OAAO,CAAC,cAAc,CAAC;CAUxC"}

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

@@ -0,0 +1,28 @@
+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;
+    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/adapters/gradle/services/gradle-module-system-factory.d.ts

@@ -0,0 +1,26 @@
+import { ModuleSystemFactory } from "../../../services/module-system-factory.js";
+import { ModuleDetector } from "../../../services/module-detector.js";
+import { VersionUpdateStrategy } from "../../../services/version-update-strategy.js";
+import { ModuleRegistry } from "../../../services/module-registry.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.
+     * @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/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;AAGrF,OAAO,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAEtE;;;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,CAAC,cAAc,EAAE,cAAc,GAAG,qBAAqB;CAGnF"}

package/dist/adapters/gradle/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/adapters/gradle/services/gradle-version-update-strategy.d.ts

@@ -0,0 +1,23 @@
+import { VersionUpdateStrategy } from "../../../services/version-update-strategy.js";
+import { ModuleRegistry } from '../../../services/module-registry.js';
+/**
+ * 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/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;AAGrF,OAAO,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAEtE;;;GAGG;AACH,qBAAa,2BAA4B,YAAW,qBAAqB;IAQzC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAP7D,mDAAmD;IACnD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IAEzC;;;OAGG;gBACS,QAAQ,EAAE,MAAM,EAAmB,cAAc,EAAE,cAAc;IAI7E;;;;OAIG;IACG,mBAAmB,CAAC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CAe9E"}

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

@@ -0,0 +1,38 @@
+import { join } from 'path';
+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 {
+    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/adapters/project-information.d.ts

@@ -0,0 +1,62 @@
+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;
+} & Record<string, unknown>;
+/**
+ * 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;
+};
+/**
+ * Base module data structure without the module ID and with version as a string.
+ */
+export type BaseModule = {
+    /** 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 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 = BaseModule & Record<string, unknown>;
+/**
+ * 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,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE5B;;;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;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,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,SAAS,GAAG,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE7D;;;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,14 @@
+import { ModuleChangeResult } from "../services/version-applier.js";
+import { Commit } from "conventional-commits-parser";
+/** Update or create a changelog file for a module. */
+export declare function updateChangelogFile(changelogContent: string, changelogPath: string, prependPlaceholder: string): Promise<void>;
+/** Generate changelog for multiple modules. */
+export declare function generateChangelogsForModules(moduleResults: ModuleChangeResult[], getCommitsForModule: (moduleId: string) => Promise<{
+    commits: Commit[];
+    lastTag: string | null;
+}>, repoRoot: string): Promise<string[]>;
+export declare function generateRootChangelog(moduleResults: ModuleChangeResult[], getCommitsForModule: (moduleId: string) => Promise<{
+    commits: Commit[];
+    lastTag: string | null;
+}>, repoRoot: string): Promise<string | undefined>;
+//# 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;AAGpE,OAAO,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAKrD,sDAAsD;AACtD,wBAAsB,mBAAmB,CACvC,gBAAgB,EAAE,MAAM,EACxB,aAAa,EAAE,MAAM,EACrB,kBAAkB,EAAE,MAAM,GACzB,OAAO,CAAC,IAAI,CAAC,CAWf;AAsBD,+CAA+C;AAC/C,wBAAsB,4BAA4B,CAChD,aAAa,EAAE,kBAAkB,EAAE,EACnC,mBAAmB,EAAE,CACnB,QAAQ,EAAE,MAAM,KACb,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,EAC3D,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,EAAE,CAAC,CAiFnB;AAED,wBAAsB,qBAAqB,CACzC,aAAa,EAAE,kBAAkB,EAAE,EACnC,mBAAmB,EAAE,CACnB,QAAQ,EAAE,MAAM,KACb,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,EAC3D,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAmF7B"}

package/dist/changelog/index.js

@@ -0,0 +1,132 @@
+import { promises as fs } from "fs";
+import path, { join } from "path";
+import { writeChangelogString } from "conventional-changelog-writer";
+import { logger } from "../utils/logger.js";
+import { exists } from "../utils/file.js";
+import { getCurrentRepoUrl, parseRepoUrl } from "../git/index.js";
+import { isReleaseVersion } from "../semver/index.js";
+/** Update or create a changelog file for a module. */
+export async function updateChangelogFile(changelogContent, changelogPath, prependPlaceholder) {
+    let fileContent = changelogContent;
+    if (await exists(changelogPath)) {
+        logger.info(`Updating existing changelog at ${changelogPath}...`);
+        // Try to read existing changelog
+        const existingContent = await fs.readFile(changelogPath, "utf8");
+        const newContent = `${prependPlaceholder}\n\n${changelogContent.trimEnd()}`;
+        fileContent = existingContent.replace(prependPlaceholder, newContent);
+    }
+    await fs.writeFile(changelogPath, fileContent, "utf8");
+}
+async function buildContextRepository(options = {}) {
+    const repoUrl = await getCurrentRepoUrl(options);
+    const { host, owner, repo } = parseRepoUrl(repoUrl);
+    return {
+        repoUrl: `https://${host}/${owner}/${repo}`,
+        host: `https://${host}`,
+        owner,
+        repository: repo,
+    };
+}
+/** Generate changelog for multiple modules. */
+export async function generateChangelogsForModules(moduleResults, getCommitsForModule, repoRoot) {
+    const changelogPaths = [];
+    const configPath = path.resolve(repoRoot, "changelog.config.js");
+    if (!(await exists(configPath))) {
+        throw new Error(`Missing required changelog configuration file at ${configPath}`);
+    }
+    logger.info(`Loading changelog configuration from ${configPath}...`);
+    const userConfig = (await import(configPath)).default.module;
+    const prependPlaceholder = userConfig.context.prependPlaceholder;
+    if (!prependPlaceholder) {
+        throw new Error("Missing required context property 'prependPlaceholder' in changelog.config.js");
+    }
+    const contextRepository = await buildContextRepository({ cwd: repoRoot });
+    for (const moduleResult of moduleResults) {
+        if (!moduleResult.declaredVersion) {
+            logger.info(`Module ${moduleResult.id} has no declared version, skipping changelog generation...`);
+            continue;
+        }
+        const { commits, lastTag } = await getCommitsForModule(moduleResult.id);
+        if (commits.length === 0) {
+            logger.info(`No commits to include in changelog for module ${moduleResult.id}, skipping...`);
+            continue;
+        }
+        const changelogPath = join(repoRoot, moduleResult.path, "CHANGELOG.md");
+        let prepend = true;
+        if (await exists(changelogPath)) {
+            prepend = false;
+        }
+        const isRelease = isReleaseVersion(moduleResult.to);
+        const version = isRelease ? moduleResult.to : undefined;
+        const currentTag = isRelease
+            ? `${moduleResult.name}@${moduleResult.to}`
+            : undefined;
+        const previousTag = lastTag || undefined;
+        const changelogContent = await writeChangelogString(commits, {
+            version: version,
+            previousTag: previousTag,
+            currentTag: currentTag,
+            linkCompare: previousTag && currentTag ? true : false,
+            ...contextRepository,
+            ...userConfig.context,
+            prepend,
+        }, userConfig.options);
+        logger.info(changelogContent);
+        await updateChangelogFile(changelogContent, changelogPath, prependPlaceholder);
+        changelogPaths.push(changelogPath);
+    }
+    return changelogPaths;
+}
+export async function generateRootChangelog(moduleResults, getCommitsForModule, repoRoot) {
+    const moduleResult = moduleResults.find((result) => result.type === "root");
+    if (!moduleResult) {
+        logger.info("No root module found, skipping root changelog generation...");
+        return;
+    }
+    const configPath = path.resolve(repoRoot, "changelog.config.js");
+    if (!(await exists(configPath))) {
+        throw new Error(`Missing required changelog configuration file at ${configPath}`);
+    }
+    logger.info(`Loading root changelog configuration from ${configPath}...`);
+    const userConfig = (await import(configPath)).default.root;
+    const prependPlaceholder = userConfig.context.prependPlaceholder;
+    if (!prependPlaceholder) {
+        throw new Error("Missing required context property 'prependPlaceholder' in changelog.config.js");
+    }
+    const contextRepository = await buildContextRepository({ cwd: repoRoot });
+    /*if (!moduleResult.declaredVersion) {
+        logger.info(
+          `Module ${moduleResult.id} has no declared version, skipping changelog generation...`,
+        );
+        return;
+      }*/
+    const { commits, lastTag } = await getCommitsForModule(moduleResult.id);
+    if (commits.length === 0) {
+        logger.info(`No commits to include in changelog for module ${moduleResult.id}, skipping...`);
+        return;
+    }
+    const changelogPath = join(repoRoot, moduleResult.path, "CHANGELOG.md");
+    let prepend = true;
+    if (await exists(changelogPath)) {
+        prepend = false;
+    }
+    const isRelease = isReleaseVersion(moduleResult.to);
+    const version = isRelease ? moduleResult.to : undefined;
+    const currentTag = isRelease
+        ? `${moduleResult.name}@${moduleResult.to}`
+        : undefined;
+    const previousTag = lastTag || undefined;
+    const changelogContent = await writeChangelogString(commits, {
+        moduleResults,
+        version: version,
+        previousTag: previousTag,
+        currentTag: currentTag,
+        linkCompare: previousTag && currentTag ? true : false,
+        ...contextRepository,
+        ...userConfig.context,
+        prepend,
+    }, userConfig.options);
+    logger.info(changelogContent);
+    await updateChangelogFile(changelogContent, changelogPath, prependPlaceholder);
+    return changelogPath;
+}