@versu/core 0.4.0

package/dist/services/version-manager.js

@@ -0,0 +1,94 @@
+import { formatSemVer } from "../semver/index.js";
+/**
+ * Manages version updates for modules with staged commits and batch persistence.
+ *
+ * @remarks
+ * Implements a two-phase update strategy:
+ * 1. Stage updates in memory via `updateVersion()`
+ * 2. Persist all updates via `commit()`
+ *
+ * Uses {@link VersionUpdateStrategy} for build system-specific operations.
+ * Validates modules against {@link ModuleRegistry}.
+ */
+export class VersionManager {
+    moduleRegistry;
+    strategy;
+    /** Pending version updates awaiting commit (module ID → version string). */
+    pendingUpdates = new Map();
+    /**
+     * Creates a new VersionManager.
+     *
+     * @param moduleRegistry - Module registry for validation
+     * @param strategy - Build system-specific strategy for writing updates
+     */
+    constructor(moduleRegistry, strategy) {
+        this.moduleRegistry = moduleRegistry;
+        this.strategy = strategy;
+    }
+    /**
+     * Stages a version update for a module without persisting to files.
+     *
+     * @param moduleId - Module identifier (e.g., `':'`, `':core'`)
+     * @param newVersion - New version as SemVer object or string
+     * @throws {Error} If module ID doesn't exist in registry
+     */
+    updateVersion(moduleId, newVersion) {
+        // Validate module exists in registry
+        if (!this.moduleRegistry.hasModule(moduleId)) {
+            throw new Error(`Module ${moduleId} not found`);
+        }
+        // Convert SemVer to string if needed, otherwise use string directly
+        const versionString = typeof newVersion === "string" ? newVersion : formatSemVer(newVersion);
+        // Store update in pending updates map
+        this.pendingUpdates.set(moduleId, versionString);
+    }
+    /**
+     * Commits all pending version updates to build files in a single batch operation.
+     *
+     * @returns Promise that resolves when all updates are written
+     * @throws {Error} If file operations fail (specific errors depend on strategy)
+     */
+    async commit() {
+        // Early return if nothing to commit
+        if (this.pendingUpdates.size === 0) {
+            return; // Nothing to commit
+        }
+        // Write all version updates using build system-specific strategy
+        await this.strategy.writeVersionUpdates(this.pendingUpdates);
+        // Clear the pending updates after successful commit
+        this.pendingUpdates.clear();
+    }
+    /**
+     * Returns a copy of all pending updates that haven't been committed.
+     *
+     * @returns Map of module ID to version string
+     */
+    getPendingUpdates() {
+        return new Map(this.pendingUpdates);
+    }
+    /**
+     * Checks whether there are any pending updates awaiting commit.
+     *
+     * @returns `true` if updates are staged, `false` otherwise
+     */
+    hasPendingUpdates() {
+        return this.pendingUpdates.size > 0;
+    }
+    /**
+     * Clears all pending updates without committing them.
+     *
+     * @remarks
+     * Use with caution - this operation cannot be undone.
+     */
+    clearPendingUpdates() {
+        this.pendingUpdates.clear();
+    }
+    /**
+     * Gets the number of pending updates in the queue.
+     *
+     * @returns The count of pending updates that have not been processed yet.
+     */
+    getPendingUpdatesCount() {
+        return this.pendingUpdates.size;
+    }
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Strategy for writing version updates to build system-specific files.
+ *
+ * @remarks
+ * Implementations handle version persistence for different build systems (Gradle, Maven, npm).
+ * Created by {@link ModuleSystemFactory} and used by {@link VersionManager}.
+ */
+export interface VersionUpdateStrategy {
+    /**
+     * Writes version updates for multiple modules to build system configuration files.
+     *
+     * @param moduleVersions - Map of module ID to new version string
+     * @returns Promise that resolves when all updates are written
+     * @throws {Error} If build files cannot be found, are not writable, or I/O operations fail
+     */
+    writeVersionUpdates(moduleVersions: Map<string, string>): Promise<void>;
+}
+//# sourceMappingURL=version-update-strategy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"version-update-strategy.d.ts","sourceRoot":"","sources":["../../src/services/version-update-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;OAMG;IACH,mBAAmB,CAAC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzE"}

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

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

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

@@ -0,0 +1,46 @@
+import { ModuleChangeResult } from "./version-applier.js";
+import { Module } from "../adapters/project-information.js";
+export type RunnerOptions = {
+    readonly repoRoot: string;
+    readonly adapter?: string;
+    readonly dryRun: boolean;
+    readonly pushTags: boolean;
+    readonly prereleaseMode: boolean;
+    readonly prereleaseId: string;
+    readonly bumpUnchanged: boolean;
+    readonly addBuildMetadata: boolean;
+    readonly timestampVersions: boolean;
+    readonly appendSnapshot: boolean;
+    readonly pushChanges: boolean;
+    readonly generateChangelog: boolean;
+    readonly outputFile: string;
+};
+export type RunnerResult = {
+    readonly bumped: boolean;
+    readonly discoveredModules: Array<Module>;
+    readonly changedModules: Array<ModuleChangeResult>;
+    readonly createdTags: string[];
+    readonly changelogPaths: string[];
+};
+export declare class VersuRunner {
+    private moduleSystemFactory;
+    private moduleRegistry;
+    private versionManager;
+    private config;
+    private adapter;
+    private options;
+    private configurationLoader;
+    private commitAnalyzer;
+    private versionBumper;
+    private versionApplier;
+    private changelogGenerator;
+    private gitOperations;
+    private adapterIdentifierRegistry;
+    private adapterMetadataProvider;
+    constructor(options: RunnerOptions);
+    private logStartupInfo;
+    private logShutdownInfo;
+    run(): Promise<RunnerResult>;
+    private doRun;
+}
+//# sourceMappingURL=versu-runner.d.ts.map

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

@@ -0,0 +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;IACpC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,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,CAAqB;IAC/C,OAAO,CAAC,aAAa,CAAiB;IACtC,OAAO,CAAC,yBAAyB,CAA4B;IAC7D,OAAO,CAAC,uBAAuB,CAA0B;gBAE7C,OAAO,EAAE,aAAa;IA0BlC,OAAO,CAAC,cAAc;IAuBtB,OAAO,CAAC,eAAe;IAgCjB,GAAG,IAAI,OAAO,CAAC,YAAY,CAAC;YAYpB,KAAK;CAkIpB"}

package/dist/services/versu-runner.js

@@ -0,0 +1,188 @@
+import { logger } from "../utils/logger.js";
+import { VersionManager } from "./version-manager.js";
+import { createModuleSystemFactory } from "../factories/module-system-factory.js";
+import { isWorkingDirectoryClean } from "../git/index.js";
+// Service imports
+import { ConfigurationLoader } from "./configuration-loader.js";
+import { CommitAnalyzer } from "./commit-analyzer.js";
+import { VersionBumper } from "./version-bumper.js";
+import { VersionApplier, } from "./version-applier.js";
+import { ChangelogGenerator } from "./changelog-generator.js";
+import { GitOperations } from "./git-operations.js";
+import { AdapterMetadataProvider } from "./adapter-metadata-provider.js";
+import { createAdapterIdentifierRegistry } from "../factories/adapter-identifier-registry.js";
+import { ConfigurationValidator } from "./configuration-validator.js";
+import { banner } from "../utils/banner.js";
+import path from "path";
+export class VersuRunner {
+    moduleSystemFactory; // Will be initialized in run()
+    moduleRegistry; // Will be initialized in run()
+    versionManager; // Will be initialized in run()
+    config; // Will be initialized in run()
+    adapter; // Will be initialized in run()
+    options;
+    // Service instances
+    configurationLoader;
+    commitAnalyzer;
+    versionBumper; // Will be initialized in run()
+    versionApplier; // Will be initialized in run()
+    changelogGenerator;
+    gitOperations; // Will be initialized in run()
+    adapterIdentifierRegistry;
+    adapterMetadataProvider;
+    constructor(options) {
+        this.options = {
+            ...options,
+            repoRoot: path.resolve(options.repoRoot),
+            outputFile: path.resolve(options.outputFile),
+        };
+        // Initialize services
+        this.configurationLoader = new ConfigurationLoader(new ConfigurationValidator());
+        this.changelogGenerator = new ChangelogGenerator({
+            generateChangelog: options.generateChangelog,
+            repoRoot: options.repoRoot,
+            dryRun: options.dryRun,
+        });
+        this.adapterIdentifierRegistry = createAdapterIdentifierRegistry();
+        this.adapterMetadataProvider = new AdapterMetadataProvider(this.adapterIdentifierRegistry, {
+            repoRoot: options.repoRoot,
+            adapter: options.adapter,
+        });
+    }
+    logStartupInfo() {
+        logger.info(banner);
+        logger.info("🌌 Version Engine for Repo Semantic Evolution");
+        logger.info("   Orchestrating your monorepo multiverse...");
+        logger.info("");
+        logger.info("🚀 Starting VERSU engine...");
+        logger.info(`Repository: ${this.options.repoRoot}`);
+        logger.info(`Output file: ${this.options.outputFile}`);
+        logger.info(`Adapter: ${this.options.adapter || "(auto-detect)"}`);
+        logger.info(`Dry run: ${this.options.dryRun}`);
+        logger.info(`Prerelease mode: ${this.options.prereleaseMode}`);
+        if (this.options.prereleaseMode) {
+            logger.info(`Prerelease ID: ${this.options.prereleaseId}`);
+            logger.info(`Bump unchanged modules: ${this.options.bumpUnchanged}`);
+        }
+        logger.info(`Add build metadata: ${this.options.addBuildMetadata}`);
+        logger.info(`Timestamp versions: ${this.options.timestampVersions}`);
+        logger.info(`Append snapshot: ${this.options.appendSnapshot}`);
+        logger.info(`Push changes: ${this.options.pushChanges}`);
+        logger.info(`Generate changelog: ${this.options.generateChangelog}`);
+        logger.info("🏃 Running VERSU semantic evolution...");
+    }
+    logShutdownInfo(result) {
+        if (!result)
+            return;
+        if (result.bumped) {
+            logger.info(`✅ Successfully updated ${result.changedModules.length} modules`);
+            for (const module of result.changedModules) {
+                logger.info(`  ${module.id}: ${module.from} → ${module.to} (${module.bumpType})`);
+            }
+            if (result.createdTags.length > 0) {
+                logger.info(`🏷️  Created ${result.createdTags.length} tags: ${result.createdTags.join(", ")}`);
+            }
+            if (result.changelogPaths.length > 0) {
+                logger.info(`📚 Generated ${result.changelogPaths.length} changelog files`);
+            }
+        }
+        else {
+            logger.info("✨ No version changes needed");
+        }
+        logger.info("");
+        logger.info("🎯 VERSU completed successfully!");
+        logger.info("   Your multiverse has evolved semantically ✨");
+    }
+    async run() {
+        this.logStartupInfo();
+        let result = null;
+        try {
+            result = await this.doRun();
+            return result;
+        }
+        finally {
+            // Any cleanup if needed
+            this.logShutdownInfo(result);
+        }
+    }
+    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
+        this.config = await this.configurationLoader.load(this.options.repoRoot);
+        // Check if working directory is clean
+        if (!this.options.dryRun &&
+            !isWorkingDirectoryClean({ cwd: this.options.repoRoot })) {
+            throw new Error("Working directory is not clean. Please commit or stash your changes.");
+        }
+        // Discover modules and get hierarchy manager
+        logger.info("🔍 Discovering modules...");
+        const detector = this.moduleSystemFactory.createDetector(this.options.outputFile);
+        this.moduleRegistry = await detector.detect();
+        // Log discovered modules through hierarchy manager
+        const moduleIds = this.moduleRegistry.getModuleIds();
+        logger.info(`Found ${moduleIds.length} modules: ${moduleIds.join(", ")}`);
+        // Analyze commits since last release
+        this.commitAnalyzer = new CommitAnalyzer(this.moduleRegistry, this.options.repoRoot);
+        const moduleCommits = await this.commitAnalyzer.analyzeCommitsSinceLastRelease();
+        // Initialize version bumper service
+        const versionBumperOptions = {
+            prereleaseMode: this.options.prereleaseMode,
+            bumpUnchanged: this.options.bumpUnchanged,
+            addBuildMetadata: this.options.addBuildMetadata,
+            appendSnapshot: this.options.appendSnapshot,
+            adapter: this.adapter,
+            timestampVersions: this.options.timestampVersions,
+            prereleaseId: this.options.prereleaseId,
+            repoRoot: this.options.repoRoot,
+            config: this.config,
+        };
+        this.versionBumper = new VersionBumper(this.moduleRegistry, versionBumperOptions);
+        // Calculate version bumps with cascade effects
+        const processedModuleChanges = await this.versionBumper.calculateVersionBumps(moduleCommits);
+        const discoveredModules = Array.from(this.moduleRegistry.getModules().values());
+        if (processedModuleChanges.length === 0) {
+            logger.info("✨ No version changes needed");
+            return {
+                bumped: false,
+                discoveredModules,
+                changedModules: [],
+                createdTags: [],
+                changelogPaths: [],
+            };
+        }
+        // Create version manager
+        const versionUpdateStrategy = this.moduleSystemFactory.createVersionUpdateStrategy(this.moduleRegistry);
+        this.versionManager = new VersionManager(this.moduleRegistry, versionUpdateStrategy);
+        // Initialize version applier and apply changes
+        const versionApplierOptions = {
+            dryRun: this.options.dryRun,
+        };
+        this.versionApplier = new VersionApplier(this.versionManager, versionApplierOptions);
+        const changedModules = await this.versionApplier.applyVersionChanges(processedModuleChanges);
+        // Generate changelogs
+        const changelogPaths = await this.changelogGenerator.generateChangelogs(changedModules, moduleCommits);
+        // Initialize git operations service
+        const gitOperationsOptions = {
+            pushChanges: this.options.pushChanges,
+            pushTags: this.options.pushTags,
+            repoRoot: this.options.repoRoot,
+            dryRun: this.options.dryRun,
+            isTemporaryVersion: this.options.prereleaseMode || this.options.appendSnapshot,
+        };
+        this.gitOperations = new GitOperations(gitOperationsOptions);
+        // Commit and push changes
+        await this.gitOperations.commitAndPushChanges(changedModules);
+        // Create and push tags
+        const createdTags = await this.gitOperations.createAndPushTags(changedModules);
+        logger.info("✅ VERSU semantic evolution completed successfully!");
+        return {
+            bumped: true,
+            discoveredModules,
+            changedModules,
+            createdTags,
+            changelogPaths,
+        };
+    }
+}

package/dist/utils/banner.d.ts

@@ -0,0 +1,2 @@
+export declare const banner: string;
+//# sourceMappingURL=banner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"banner.d.ts","sourceRoot":"","sources":["../../src/utils/banner.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,MAAM,EAAE,MASpB,CAAC"}

package/dist/utils/banner.js

@@ -0,0 +1,12 @@
+import { VERSION, PACKAGE_NAME } from "./version.js";
+const info = `${PACKAGE_NAME} v${VERSION}`;
+export const banner = `
+██╗   ██╗███████╗██████╗ ███████╗██╗   ██╗
+██║   ██║██╔════╝██╔══██╗██╔════╝██║   ██║
+██║   ██║█████╗  ██████╔╝███████╗██║   ██║
+╚██╗ ██╔╝██╔══╝  ██╔══██╗╚════██║██║   ██║
+ ╚████╔╝ ███████╗██║  ██║███████║╚██████╔╝
+  ╚═══╝  ╚══════╝╚═╝  ╚═╝╚══════╝ ╚═════╝ 
+
+${info.padStart(44)}
+`;

package/dist/utils/commits.d.ts

@@ -0,0 +1,12 @@
+import { Commit } from "conventional-commits-parser";
+import { Config } from "../config/index.js";
+import { BumpType } from "../semver/index.js";
+/**
+ * Calculates the overall semantic version bump type from a collection of commits.
+ * Returns the highest bump type: major > minor > patch > none.
+ * @param commits - Array of commit information to analyze
+ * @param config - Configuration containing commit type mappings
+ * @returns The highest BumpType required across all commits
+ */
+export declare function calculateBumpFromCommits(commits: Commit[], config: Config): BumpType;
+//# sourceMappingURL=commits.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"commits.d.ts","sourceRoot":"","sources":["../../src/utils/commits.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AACrD,OAAO,EAAwB,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAe,MAAM,oBAAoB,CAAC;AAE3D;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EAAE,EACjB,MAAM,EAAE,MAAM,GACb,QAAQ,CAiBV"}

package/dist/utils/commits.js

@@ -0,0 +1,24 @@
+import { getBumpTypeForCommit } from "../config/index.js";
+import { maxBumpType } from "../semver/index.js";
+/**
+ * Calculates the overall semantic version bump type from a collection of commits.
+ * Returns the highest bump type: major > minor > patch > none.
+ * @param commits - Array of commit information to analyze
+ * @param config - Configuration containing commit type mappings
+ * @returns The highest BumpType required across all commits
+ */
+export function calculateBumpFromCommits(commits, config) {
+    // Collect bump types for all commits
+    const bumpTypes = [];
+    // Analyze each commit and determine its version impact
+    for (const commit of commits) {
+        const bumpType = getBumpTypeForCommit(commit, config);
+        // Only include commits that require a version bump
+        if (bumpType !== "none") {
+            bumpTypes.push(bumpType);
+        }
+    }
+    // Return the highest bump type required across all commits
+    // If no meaningful commits found, returns 'none'
+    return maxBumpType(bumpTypes);
+}

package/dist/utils/file.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks whether a file or directory exists at the specified path.
+ * @param path - Absolute or relative path to check
+ * @returns True if the path exists and is accessible, false otherwise
+ */
+export declare function exists(path: string): Promise<boolean>;
+//# sourceMappingURL=file.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/utils/file.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAW3D"}

package/dist/utils/file.js

@@ -0,0 +1,19 @@
+import { promises as fs } from "fs";
+/**
+ * Checks whether a file or directory exists at the specified path.
+ * @param path - Absolute or relative path to check
+ * @returns True if the path exists and is accessible, false otherwise
+ */
+export async function exists(path) {
+    try {
+        // Attempt to access the path
+        // If access succeeds, the path exists and is accessible
+        await fs.access(path);
+        return true;
+    }
+    catch {
+        // If access fails (any error), consider path as non-existent
+        // This includes ENOENT (doesn't exist) and EACCES (no permission)
+        return false;
+    }
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./commits.js";
+export * from "./file.js";
+export * from "./properties.js";
+export * from "./versioning.js";
+export * from "./logger.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,5 @@
+export * from "./commits.js";
+export * from "./file.js";
+export * from "./properties.js";
+export * from "./versioning.js";
+export * from "./logger.js";

package/dist/utils/logger.d.ts

@@ -0,0 +1,14 @@
+export interface Logger {
+    debug(message: string): void;
+    info(message: string): void;
+    warning(message: string | Error, context?: Record<string, unknown>): void;
+    error(message: string | Error, context?: Record<string, unknown>): void;
+}
+export declare function initLogger(logger: Logger): void;
+/**
+ * Convenience proxy so existing call sites can
+ * import `logger` and call methods. The proxy delegates
+ * to the mutable `_current` at call-time.
+ */
+export declare const logger: Logger;
+//# sourceMappingURL=logger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,MAAM;IACrB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC1E,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CACzE;AAYD,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,QAExC;AAED;;;;GAIG;AACH,eAAO,MAAM,MAAM,EAAE,MAOpB,CAAC"}

package/dist/utils/logger.js

@@ -0,0 +1,22 @@
+// default no-op
+const noopLogger = {
+    debug: (_message) => { },
+    info: (_message) => { },
+    warning: (_message, _context) => { },
+    error: (_message, _context) => { },
+};
+let _current = noopLogger;
+export function initLogger(logger) {
+    _current = logger;
+}
+/**
+ * Convenience proxy so existing call sites can
+ * import `logger` and call methods. The proxy delegates
+ * to the mutable `_current` at call-time.
+ */
+export const logger = {
+    debug: (message) => _current.debug(message),
+    info: (message) => _current.info(message),
+    warning: (message, context) => _current.warning(message, context),
+    error: (message, context) => _current.error(message, context),
+};

package/dist/utils/properties.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Parse a generic properties file into key-value pairs
+ * Supports both '=' and ':' as delimiters
+ * Skips comments (lines starting with # or !) and empty lines
+ * @param propertiesPath - Path to the properties file
+ * @returns Map of property keys to values
+ */
+export declare function parseProperties(propertiesPath: string): Promise<Map<string, string>>;
+/**
+ * Updates or inserts a single property in a Java-style properties file.
+ * @param propertiesPath - Path to the properties file
+ * @param key - Property key to update or insert
+ * @param value - Property value to set
+ */
+export declare function upsertProperty(propertiesPath: string, key: string, value: string): Promise<void>;
+/**
+ * Updates or inserts multiple properties in a Java-style properties file.
+ * Updates existing properties in place, appends new ones to the end.
+ * @param propertiesPath - Path to the properties file
+ * @param properties - Map of property keys to values
+ * @throws {Error} If file operations fail
+ */
+export declare function upsertProperties(propertiesPath: string, properties: Map<string, string>): Promise<void>;
+//# sourceMappingURL=properties.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"properties.d.ts","sourceRoot":"","sources":["../../src/utils/properties.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,wBAAsB,eAAe,CACnC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiC9B;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,cAAc,EAAE,MAAM,EACtB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAGf;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CACpC,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,OAAO,CAAC,IAAI,CAAC,CAgDf"}

package/dist/utils/properties.js

@@ -0,0 +1,94 @@
+import { promises as fs } from "fs";
+import { exists } from "./file.js";
+/**
+ * Parse a generic properties file into key-value pairs
+ * Supports both '=' and ':' as delimiters
+ * Skips comments (lines starting with # or !) and empty lines
+ * @param propertiesPath - Path to the properties file
+ * @returns Map of property keys to values
+ */
+export async function parseProperties(propertiesPath) {
+    const content = await fs.readFile(propertiesPath, "utf8");
+    const properties = new Map();
+    // Parse all properties line by line
+    const lines = content.split("\n");
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        // Skip comments and empty lines
+        if (trimmedLine.startsWith("#") ||
+            trimmedLine.startsWith("!") ||
+            !trimmedLine) {
+            continue;
+        }
+        // Parse property: key=value or key:value
+        const match = trimmedLine.match(/^([^=:]+)[=:]\s*(.+)$/);
+        if (!match) {
+            continue;
+        }
+        const [, key, value] = match;
+        const trimmedKey = key.trim();
+        const trimmedValue = value.trim();
+        properties.set(trimmedKey, trimmedValue);
+    }
+    return properties;
+}
+/**
+ * Updates or inserts a single property in a Java-style properties file.
+ * @param propertiesPath - Path to the properties file
+ * @param key - Property key to update or insert
+ * @param value - Property value to set
+ */
+export async function upsertProperty(propertiesPath, key, value) {
+    // Delegate to batch function with single-entry map
+    await upsertProperties(propertiesPath, new Map([[key, value]]));
+}
+/**
+ * Updates or inserts multiple properties in a Java-style properties file.
+ * Updates existing properties in place, appends new ones to the end.
+ * @param propertiesPath - Path to the properties file
+ * @param properties - Map of property keys to values
+ * @throws {Error} If file operations fail
+ */
+export async function upsertProperties(propertiesPath, properties) {
+    // Early return for empty updates (optimization)
+    if (properties.size === 0) {
+        return; // Nothing to update
+    }
+    // Check if properties file already exists
+    const propertiesExist = await exists(propertiesPath);
+    let updatedContent;
+    if (propertiesExist) {
+        // File exists - read current content and update properties
+        let content = await fs.readFile(propertiesPath, "utf8");
+        // Process each property update
+        for (const [key, value] of properties) {
+            // Escape special regex characters in property key
+            // This ensures keys like 'my.app.version' don't become regex patterns
+            const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            // Match property lines: key=value or key:value (with optional whitespace)
+            // Anchored to line start (^) and end ($) with multiline flag (m)
+            const propertyRegex = new RegExp(`^${escapedKey}\\s*[=:]\\s*.*$`, "m");
+            if (propertyRegex.test(content)) {
+                // Property exists - replace the line with updated value
+                content = content.replace(propertyRegex, `${key}=${value}`);
+            }
+            else {
+                // Property doesn't exist - append to end of file
+                // Add newline separator if file doesn't end with one
+                const separator = content.endsWith("\n") ? "" : "\n";
+                content = content + separator + `${key}=${value}\n`;
+            }
+        }
+        updatedContent = content;
+    }
+    else {
+        // File doesn't exist - create new properties content
+        const lines = [];
+        for (const [key, value] of properties) {
+            lines.push(`${key}=${value}`);
+        }
+        updatedContent = lines.join("\n") + "\n";
+    }
+    // Write updated content to file (creates or overwrites)
+    await fs.writeFile(propertiesPath, updatedContent, "utf8");
+}

package/dist/utils/version.d.ts

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

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

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

package/dist/utils/version.js

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