@versu/core 0.5.1 → 0.6.0

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

@@ -1 +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;AAIrD,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAE3E,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,EAChB,MAAM,CAAC,EAAE,qBAAqB,GAC7B,OAAO,CAAC,MAAM,EAAE,CAAC,CA4EnB;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,EAChB,MAAM,CAAC,EAAE,qBAAqB,GAC7B,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAgF7B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/changelog/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAOpE,OAAO,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAIrD,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAE3E,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,EAChB,MAAM,CAAC,EAAE,qBAAqB,GAC7B,OAAO,CAAC,MAAM,EAAE,CAAC,CAwEnB;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,EAChB,MAAM,CAAC,EAAE,qBAAqB,GAC7B,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CA4E7B"}

package/dist/changelog/index.js

@@ -1,6 +1,6 @@
 import { promises as fs } from "fs";
 import { join } from "path";
-import { writeChangelogString } from "conventional-changelog-writer";
+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";

package/dist/config/index.d.ts

@@ -90,6 +90,7 @@ export declare const configSchema: z.ZodObject<{
         versionSource: z.ZodArray<z.ZodLiteral<"package.json">>;
         updatePackageLock: z.ZodBoolean;
     }, z.core.$strip>>;
+    plugins: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
     changelog: z.ZodOptional<z.ZodObject<{
         root: z.ZodOptional<z.ZodObject<{
             context: z.ZodObject<{

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAqBrD;;;GAGG;AACH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;iBAIzB,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,kBAAkB;;;iBAGtB,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;kBAmBf,CAAC;AAEd;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWvB,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,MAmB5B,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAe7E;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,kBAAkB,EAAE,QAAQ,EAC5B,MAAM,EAAE,MAAM,GACb,QAAQ,CAaV;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,MAAM,EACrD,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,CAAC,GACb,MAAM,CAAC,CAAC,CAAC,CAEX"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAqBrD;;;GAGG;AACH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;iBAIzB,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,kBAAkB;;;iBAGtB,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;kBAmBf,CAAC;AAEd;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYvB,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,MAoB5B,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAe7E;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,kBAAkB,EAAE,QAAQ,EAC5B,MAAM,EAAE,MAAM,GACb,QAAQ,CAaV;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,MAAM,EACrD,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,CAAC,GACb,MAAM,CAAC,CAAC,CAAC,CAEX"}

package/dist/config/index.js

@@ -63,6 +63,7 @@ export const configSchema = z.object({
     commitTypes: z.record(z.string(), bumpTypeOrIgnoreSchema),
     dependencyRules: dependencyRulesSchema,
     nodejs: nodeJSConfigSchema.optional(),
+    plugins: z.array(z.string()).optional().default([]),
     changelog: z
         .object({
         root: changelogSchema,
@@ -88,6 +89,7 @@ export const DEFAULT_CONFIG = {
         ci: "ignore",
         build: "ignore",
     },
+    plugins: [],
     dependencyRules: {
         onMajorOfDependency: "major",
         onMinorOfDependency: "minor",

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

@@ -1,4 +1,5 @@
 import { AdapterIdentifierRegistry } from "../services/adapter-identifier-registry.js";
+import { PluginContract } from "../plugins/plugin-loader.js";
 /**
  * Creates and configures the global adapter identifier registry.
  *
@@ -8,5 +9,5 @@ import { AdapterIdentifierRegistry } from "../services/adapter-identifier-regist
  * Central point for registering all supported project adapters.
  * To add a new adapter, implement {@link AdapterIdentifier} and add it to the array.
  */
-export declare function createAdapterIdentifierRegistry(): AdapterIdentifierRegistry;
+export declare function createAdapterIdentifierRegistry(plugins: PluginContract[]): AdapterIdentifierRegistry;
 //# sourceMappingURL=adapter-identifier-registry.d.ts.map

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

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

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

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

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

@@ -1,4 +1,5 @@
 import { ModuleSystemFactory } from "../services/module-system-factory.js";
+import { AdapterPluginContract } from "../plugins/plugin-loader.js";
 /**
  * Creates the appropriate module system factory for a given adapter.
  * @param adapterName - The identifier of the build system adapter (e.g., 'gradle', 'maven', 'npm')
@@ -6,5 +7,5 @@ import { ModuleSystemFactory } from "../services/module-system-factory.js";
  * @returns A ModuleSystemFactory instance configured for the specified adapter
  * @throws {Error} If the adapter name is not recognized or supported
  */
-export declare function createModuleSystemFactory(adapterName: string, repoRoot: string): ModuleSystemFactory;
+export declare function createModuleSystemFactory(adapterName: string, adapterPlugins: AdapterPluginContract[], repoRoot: string): ModuleSystemFactory;
 //# sourceMappingURL=module-system-factory.d.ts.map

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

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

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

@@ -1,5 +1,3 @@
-import { GradleModuleSystemFactory } from "../adapters/gradle/services/gradle-module-system-factory.js";
-import { GRADLE_ID } from "../adapters/gradle/constants.js";
 /**
  * Creates the appropriate module system factory for a given adapter.
  * @param adapterName - The identifier of the build system adapter (e.g., 'gradle', 'maven', 'npm')
@@ -7,12 +5,11 @@ import { GRADLE_ID } from "../adapters/gradle/constants.js";
  * @returns A ModuleSystemFactory instance configured for the specified adapter
  * @throws {Error} If the adapter name is not recognized or supported
  */
-export function createModuleSystemFactory(adapterName, repoRoot) {
-    // Normalize adapter name to lowercase for case-insensitive matching
-    switch (adapterName.toLowerCase()) {
-        case GRADLE_ID:
-            return new GradleModuleSystemFactory(repoRoot);
-        default:
-            throw new Error(`Unsupported adapter: ${adapterName}`);
+export function createModuleSystemFactory(adapterName, adapterPlugins, repoRoot) {
+    const lowerCasedAdapterName = adapterName.toLowerCase();
+    const candidatePlugin = adapterPlugins.find((plugin) => plugin.id.toLowerCase() === lowerCasedAdapterName);
+    if (!candidatePlugin) {
+        throw new Error(`Unsupported adapter: ${adapterName}`);
     }
+    return candidatePlugin.moduleSystemFactory(repoRoot);
 }

package/dist/index.d.ts

@@ -14,7 +14,9 @@ export { CommitAnalyzer } from './services/commit-analyzer.js';
 export { ConfigurationLoader } from './services/configuration-loader.js';
 export type { AdapterIdentifier, AdapterMetadata } from './services/adapter-identifier.js';
 export { AdapterIdentifierRegistry } from './services/adapter-identifier-registry.js';
-export type { ProjectInformation, Module } from './adapters/project-information.js';
+export type { ModuleDetector } from './services/module-detector.js';
+export type { VersionUpdateStrategy } from './services/version-update-strategy.js';
+export type { RawProjectInformation, ProjectInformation, Module, BaseModule } from './adapters/project-information.js';
 export { createModuleSystemFactory } from './factories/module-system-factory.js';
 export type { ModuleSystemFactory } from './services/module-system-factory.js';
 export * from './git/index.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,cAAc,mBAAmB,CAAC;AAGlC,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,YAAY,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,YAAY,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAC/F,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,YAAY,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AACzE,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC3F,OAAO,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AAGtF,YAAY,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,mCAAmC,CAAC;AAGpF,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AACjF,YAAY,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAG/E,cAAc,gBAAgB,CAAC;AAG/B,cAAc,mBAAmB,CAAC;AAGlC,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,cAAc,mBAAmB,CAAC;AAGlC,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,YAAY,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,YAAY,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAC/F,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,YAAY,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AACzE,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC3F,OAAO,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AACtF,YAAY,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACpE,YAAY,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAGnF,YAAY,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAGvH,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AACjF,YAAY,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAG/E,cAAc,gBAAgB,CAAC;AAG/B,cAAc,mBAAmB,CAAC;AAGlC,cAAc,kBAAkB,CAAC"}

package/dist/plugins/plugin-loader.d.ts

@@ -0,0 +1,38 @@
+import { AdapterIdentifier } from "../services/adapter-identifier.js";
+import { ModuleSystemFactory } from "../services/module-system-factory.js";
+export type PluginContract = {
+    id: string;
+    name: string;
+    description: string;
+    version: string;
+    author: string;
+    adapters: AdapterPluginContract[];
+};
+export type AdapterPluginContract = {
+    id: string;
+    adapterIdentifier: () => AdapterIdentifier;
+    moduleSystemFactory: (repoRoot: string) => ModuleSystemFactory;
+};
+export type PluginLoaderOptions = {
+    plugins: string[];
+};
+export declare class PluginLoader {
+    private readonly _plugins;
+    get plugins(): PluginContract[];
+    /**
+     * 1. Find the global node_modules path
+     * This is safer than guessing strings because it varies by OS (Windows vs Mac)
+     */
+    private getGlobalNodeModulesPath;
+    /**
+     * 2. Load ONLY the plugins specified in the whitelist
+     * @param pluginNames List of package names (e.g. ['my-plugin-alpha', '@scope/my-plugin-beta'])
+     */
+    loadSelectedPlugins(pluginNames: string[]): Promise<void>;
+    /**
+     * 3. Dynamically require the plugin
+     */
+    private loadSinglePlugin;
+    private isValidPlugin;
+}
+//# sourceMappingURL=plugin-loader.d.ts.map

package/dist/plugins/plugin-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-loader.d.ts","sourceRoot":"","sources":["../../src/plugins/plugin-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAM3E,MAAM,MAAM,cAAc,GAAG;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,qBAAqB,EAAE,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;IAC3C,mBAAmB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,mBAAmB,CAAC;CAChE,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAEF,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0C;IAEnE,IAAI,OAAO,IAAI,cAAc,EAAE,CAE9B;IAED;;;OAGG;YACW,wBAAwB;IActC;;;OAGG;IACU,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE;IAyBtD;;OAEG;YACW,gBAAgB;IAoC9B,OAAO,CAAC,aAAa;CAGtB"}

package/dist/plugins/plugin-loader.js

@@ -0,0 +1,85 @@
+import * as path from "path";
+import { execa } from "execa";
+import { exists } from "../utils/file.js";
+import { logger } from "../utils/logger.js";
+export class PluginLoader {
+    _plugins = new Map();
+    get plugins() {
+        return Array.from(this._plugins.values());
+    }
+    /**
+     * 1. Find the global node_modules path
+     * This is safer than guessing strings because it varies by OS (Windows vs Mac)
+     */
+    async getGlobalNodeModulesPath() {
+        try {
+            // Ask npm where the global root is
+            const { stdout } = await execa("npm", ["root", "-g"], {
+                encoding: "utf8",
+            });
+            const root = stdout.trim();
+            return root;
+        }
+        catch (e) {
+            logger.error("Could not determine global path");
+            return "";
+        }
+    }
+    /**
+     * 2. Load ONLY the plugins specified in the whitelist
+     * @param pluginNames List of package names (e.g. ['my-plugin-alpha', '@scope/my-plugin-beta'])
+     */
+    async loadSelectedPlugins(pluginNames) {
+        logger.info(`🔍 Loading plugins...`);
+        const globalRoot = await this.getGlobalNodeModulesPath();
+        if (!globalRoot || !(await exists(globalRoot))) {
+            logger.error(`❌ Global node_modules not found at: ${globalRoot}`);
+            return;
+        }
+        logger.info(`Plugins to load: ${pluginNames.join(", ")}`);
+        pluginNames.forEach(async (pluginName) => {
+            // Construct the absolute path to the specific package
+            const pluginPath = path.join(globalRoot, pluginName);
+            if (await exists(pluginPath)) {
+                await this.loadSinglePlugin(pluginPath);
+            }
+            else {
+                logger.warning(`⚠️  Plugin not found: ${pluginName} (looked in ${globalRoot})`);
+                logger.warning(`   Run 'npm install -g ${pluginName}' to fix this.`);
+            }
+        });
+    }
+    /**
+     * 3. Dynamically require the plugin
+     */
+    async loadSinglePlugin(absolutePath) {
+        try {
+            // Dynamic require using the absolute path
+            // Note: If using ESM (import), use await import(absolutePath)
+            const rawModule = await import(absolutePath);
+            // Handle both "export default" and "module.exports"
+            const plugin = rawModule.default;
+            const isValid = this.isValidPlugin(plugin);
+            const isAlreadyLoaded = this._plugins.has(plugin.id);
+            if (!isValid) {
+                logger.error(`❌ Invalid plugin structure at ${absolutePath}. Missing required properties or methods.`);
+                return;
+            }
+            if (isAlreadyLoaded) {
+                logger.warning(`⚠️  Plugin with ID '${plugin.id}' is already loaded. Skipping duplicate from ${absolutePath}.`);
+                return;
+            }
+            this._plugins.set(plugin.id, plugin);
+            logger.info(`✅ Loaded: ${plugin.name}`);
+        }
+        catch (err) {
+            logger.error(`❌ Failed to load plugin at ${absolutePath}`, {
+                error: err,
+            });
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    isValidPlugin(plugin) {
+        return plugin && typeof plugin.onInit === "function";
+    }
+}

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

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

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

@@ -58,7 +58,9 @@ export class AdapterMetadataProvider {
         if (!identifier) {
             throw new Error("No project adapter could be auto-detected. " +
                 'Please specify the "adapter" input explicitly in your workflow. ' +
-                "Supported adapters: gradle. For more information, see the documentation.");
+                "Supported adapters: " +
+                this.adapterIdentifierRegistry.getSupportedAdapters().join(", ") +
+                ". For more information, see the documentation.");
         }
         logger.info(`🔍 Auto-detected adapter: ${identifier.metadata.id}`);
         return identifier;

package/dist/services/configuration-loader.js

@@ -16,7 +16,7 @@ export class ConfigurationLoader {
     constructor(configurationValidator) {
         this.configurationValidator = configurationValidator;
         // Initialize cosmiconfig explorer once for reuse across multiple loads
-        this.explorer = cosmiconfig("versu", { searchStrategy: 'global' });
+        this.explorer = cosmiconfig("versu", { searchStrategy: "global" });
     }
     /**
      * Loads and validates the VERSU configuration.

package/dist/services/versu-runner.d.ts

@@ -36,6 +36,7 @@ export declare class VersuRunner {
     private gitOperations;
     private adapterIdentifierRegistry;
     private adapterMetadataProvider;
+    private pluginLoader;
     constructor(options: RunnerOptions);
     private logStartupInfo;
     private logShutdownInfo;

package/dist/services/versu-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"versu-runner.d.ts","sourceRoot":"","sources":["../../src/services/versu-runner.ts"],"names":[],"mappings":"AAYA,OAAO,EAGL,kBAAkB,EACnB,MAAM,sBAAsB,CAAC;AAO9B,OAAO,EAAE,MAAM,EAAE,MAAM,oCAAoC,CAAC;AAK5D,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1C,QAAQ,CAAC,cAAc,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAC;IACnD,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC;IAC/B,QAAQ,CAAC,cAAc,EAAE,MAAM,EAAE,CAAC;CACnC,CAAC;AAEF,qBAAa,WAAW;IACtB,OAAO,CAAC,mBAAmB,CAAuB;IAClD,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,OAAO,CAAgB;IAG/B,OAAO,CAAC,mBAAmB,CAAsB;IACjD,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,aAAa,CAAiB;IACtC,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,kBAAkB,CAAsB;IAChD,OAAO,CAAC,aAAa,CAAiB;IACtC,OAAO,CAAC,yBAAyB,CAA4B;IAC7D,OAAO,CAAC,uBAAuB,CAA0B;gBAE7C,OAAO,EAAE,aAAa;IAoBlC,OAAO,CAAC,cAAc;IAqBtB,OAAO,CAAC,eAAe;IAgCjB,GAAG,IAAI,OAAO,CAAC,YAAY,CAAC;YAYpB,KAAK;CA0IpB"}
+{"version":3,"file":"versu-runner.d.ts","sourceRoot":"","sources":["../../src/services/versu-runner.ts"],"names":[],"mappings":"AAYA,OAAO,EAGL,kBAAkB,EACnB,MAAM,sBAAsB,CAAC;AAO9B,OAAO,EAAE,MAAM,EAAE,MAAM,oCAAoC,CAAC;AAM5D,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1C,QAAQ,CAAC,cAAc,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAC;IACnD,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC;IAC/B,QAAQ,CAAC,cAAc,EAAE,MAAM,EAAE,CAAC;CACnC,CAAC;AAEF,qBAAa,WAAW;IACtB,OAAO,CAAC,mBAAmB,CAAuB;IAClD,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,OAAO,CAAgB;IAG/B,OAAO,CAAC,mBAAmB,CAAsB;IACjD,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,aAAa,CAAiB;IACtC,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,kBAAkB,CAAsB;IAChD,OAAO,CAAC,aAAa,CAAiB;IACtC,OAAO,CAAC,yBAAyB,CAA6B;IAC9D,OAAO,CAAC,uBAAuB,CAA2B;IAC1D,OAAO,CAAC,YAAY,CAAgB;gBAExB,OAAO,EAAE,aAAa;IAYlC,OAAO,CAAC,cAAc;IAuBtB,OAAO,CAAC,eAAe;IAgCjB,GAAG,IAAI,OAAO,CAAC,YAAY,CAAC;YAYpB,KAAK;CA0JpB"}

package/dist/services/versu-runner.js

@@ -14,6 +14,7 @@ import { createAdapterIdentifierRegistry } from "../factories/adapter-identifier
 import { ConfigurationValidator } from "./configuration-validator.js";
 import { banner } from "../utils/banner.js";
 import path from "path";
+import { PluginLoader } from "../plugins/plugin-loader.js";
 export class VersuRunner {
     moduleSystemFactory; // Will be initialized in run()
     moduleRegistry; // Will be initialized in run()
@@ -30,6 +31,7 @@ export class VersuRunner {
     gitOperations; // Will be initialized in run()
     adapterIdentifierRegistry;
     adapterMetadataProvider;
+    pluginLoader; // Will be initialized in run()
     constructor(options) {
         this.options = {
             ...options,
@@ -37,11 +39,6 @@ export class VersuRunner {
         };
         // Initialize services
         this.configurationLoader = new ConfigurationLoader(new ConfigurationValidator());
-        this.adapterIdentifierRegistry = createAdapterIdentifierRegistry();
-        this.adapterMetadataProvider = new AdapterMetadataProvider(this.adapterIdentifierRegistry, {
-            repoRoot: options.repoRoot,
-            adapter: options.adapter,
-        });
     }
     logStartupInfo() {
         logger.info(banner);
@@ -98,12 +95,20 @@ export class VersuRunner {
         }
     }
     async doRun() {
-        this.adapter = await this.adapterMetadataProvider.getMetadata();
-        // Initialize module system factory with resolved adapter
-        this.moduleSystemFactory = createModuleSystemFactory(this.adapter.id, this.options.repoRoot);
         // Load configuration
         const configDirectory = path.join(this.options.repoRoot, ".versu");
         this.config = await this.configurationLoader.load(configDirectory);
+        this.pluginLoader = new PluginLoader();
+        await this.pluginLoader.loadSelectedPlugins(this.config.plugins);
+        const plugins = this.pluginLoader.plugins;
+        this.adapterIdentifierRegistry = createAdapterIdentifierRegistry(plugins);
+        this.adapterMetadataProvider = new AdapterMetadataProvider(this.adapterIdentifierRegistry, {
+            repoRoot: this.options.repoRoot,
+            adapter: this.options.adapter,
+        });
+        this.adapter = await this.adapterMetadataProvider.getMetadata();
+        // Initialize module system factory with resolved adapter
+        this.moduleSystemFactory = createModuleSystemFactory(this.adapter.id, plugins.flatMap((plugin) => plugin.adapters), this.options.repoRoot);
         // Check if working directory is clean
         if (!this.options.dryRun &&
             !isWorkingDirectoryClean({ cwd: this.options.repoRoot })) {
@@ -111,7 +116,7 @@ export class VersuRunner {
         }
         // Discover modules and get hierarchy manager
         logger.info("🔍 Discovering modules...");
-        const detector = this.moduleSystemFactory.createDetector(path.resolve(path.join(configDirectory, 'project-information.json')));
+        const detector = this.moduleSystemFactory.createDetector(path.resolve(path.join(configDirectory, "project-information.json")));
         this.moduleRegistry = await detector.detect();
         // Log discovered modules through hierarchy manager
         const moduleIds = this.moduleRegistry.getModuleIds();

package/dist/utils/version.d.ts

@@ -1,3 +1,3 @@
-export declare const VERSION = "0.5.1";
+export declare const VERSION = "0.6.0";
 export declare const PACKAGE_NAME = "@versu/core";
 //# sourceMappingURL=version.d.ts.map

package/dist/utils/version.js

@@ -1,4 +1,4 @@
 // This file is auto-generated. Do not edit manually.
 // Run 'npm run generate-version' to update this file.
-export const VERSION = "0.5.1";
+export const VERSION = "0.6.0";
 export const PACKAGE_NAME = "@versu/core";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@versu/core",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "VERSU (Core Library)",
   "type": "module",
   "main": "dist/index.js",
@@ -13,13 +13,12 @@
   "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",
+    "build:esm": "tsc --project tsconfig.json --outDir dist",
+    "build:cjs": "tsc --project tsconfig.cjs.json --outDir dist",
     "test": "vitest",
     "test:coverage": "vitest --coverage",
     "lint": "eslint src/**/*.ts",
-    "format": "prettier --write src/**/*.ts",
-    "copy-assets": "cpx \"src/adapters/gradle/init-project-information.gradle.kts\" \"dist/adapters/gradle/\""
+    "format": "prettier --write src/**/*.ts"
   },
   "keywords": [
     "versu",

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

@@ -1,13 +0,0 @@
-/** 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

@@ -1 +0,0 @@
-{"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

@@ -1,12 +0,0 @@
-/** 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

@@ -1,19 +0,0 @@
-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
- * @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/adapters/gradle/gradle-project-information.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gradle-project-information.d.ts","sourceRoot":"","sources":["../../../src/adapters/gradle/gradle-project-information.ts"],"names":[],"mappings":"AAGA,OAAO,EAAsB,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AA4H1G;;;;;;;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/adapters/gradle/gradle-project-information.js

@@ -1,235 +0,0 @@
-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';
-import fs from 'fs/promises';
-import crypto from 'crypto';
-import fg from 'fast-glob';
-import { parseProperties } from '../../utils/properties.js';
-import { logger } from '../../utils/logger.js';
-/**
- * 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/adapters/gradle/init-project-information.gradle.kts

@@ -1,163 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,44 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,28 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,29 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,38 +0,0 @@
-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);
-    }
-}