@eldrforge/shared 0.1.1-dev.1

package/dist/index.js

@@ -0,0 +1,1092 @@
+import * as fs from 'fs';
+import { glob } from 'glob';
+import path from 'path';
+import crypto from 'crypto';
+import dayjs from 'dayjs';
+import timezone from 'dayjs/plugin/timezone.js';
+import utc from 'dayjs/plugin/utc.js';
+import moment from 'moment-timezone';
+import { safeJsonParse as safeJsonParse$1, validatePackageJson } from '@eldrforge/git-tools';
+
+/**
+ * Logger utilities
+ * Provides optional Winston integration with console fallback
+ */ let logger;
+/**
+ * Set the logger instance
+ */ function setLogger(newLogger) {
+    logger = newLogger;
+}
+/**
+ * Get the current logger or create a console fallback
+ */ function getLogger() {
+    if (logger) {
+        return logger;
+    }
+    // Console fallback
+    /* eslint-disable no-console */ return {
+        error: (message, ...args)=>console.error(message, ...args),
+        warn: (message, ...args)=>console.warn(message, ...args),
+        info: (message, ...args)=>console.log(message, ...args),
+        debug: (message, ...args)=>console.debug(message, ...args)
+    };
+/* eslint-enable no-console */ }
+
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class ArgumentError extends Error {
+    get argument() {
+        return this.argumentName;
+    }
+    constructor(argumentName, message){
+        super(`${message}`), _define_property$1(this, "argumentName", void 0);
+        this.name = 'ArgumentError';
+        this.argumentName = argumentName;
+    }
+}
+
+class CancellationError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'CancellationError';
+    }
+}
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Base class for all command-related errors
+ */ class CommandError extends Error {
+    constructor(message, code, recoverable = false, cause){
+        super(message), _define_property(this, "code", void 0), _define_property(this, "recoverable", void 0), _define_property(this, "originalCause", void 0);
+        this.name = 'CommandError';
+        this.code = code;
+        this.recoverable = recoverable;
+        this.originalCause = cause;
+        // Also set the standard cause property for compatibility
+        if (cause) {
+            this.cause = cause;
+        }
+    }
+}
+/**
+ * Configuration-related errors (missing config, invalid settings, etc.)
+ */ class ConfigurationError extends CommandError {
+    constructor(message, cause){
+        super(message, 'CONFIG_ERROR', false, cause);
+        this.name = 'ConfigurationError';
+    }
+}
+/**
+ * Validation errors (invalid arguments, missing required data, etc.)
+ */ class ValidationError extends CommandError {
+    constructor(message, cause){
+        super(message, 'VALIDATION_ERROR', false, cause);
+        this.name = 'ValidationError';
+    }
+}
+/**
+ * User cancellation errors (user cancelled operation)
+ */ class UserCancellationError extends CommandError {
+    constructor(message = 'Operation cancelled by user'){
+        super(message, 'USER_CANCELLED', true);
+        this.name = 'UserCancellationError';
+    }
+}
+/**
+ * External dependency errors (Git, NPM, file system, etc.)
+ */ class ExternalDependencyError extends CommandError {
+    constructor(message, dependency, cause){
+        super(`${dependency}: ${message}`, 'EXTERNAL_DEPENDENCY_ERROR', false, cause);
+        this.name = 'ExternalDependencyError';
+    }
+}
+/**
+ * File operation errors (read, write, permissions, etc.)
+ */ class FileOperationError extends CommandError {
+    constructor(message, filePath, cause){
+        super(`File operation failed on ${filePath}: ${message}`, 'FILE_OPERATION_ERROR', false, cause);
+        this.name = 'FileOperationError';
+    }
+}
+/**
+ * Pull request check failures with detailed information
+ */ class PullRequestCheckError extends CommandError {
+    /**
+     * Get specific instructions based on the type of failures
+     */ getRecoveryInstructions() {
+        const instructions = [];
+        const branchName = this.currentBranch || 'your current branch';
+        // Analyze failure types for specific guidance
+        const testFailures = this.failedChecks.filter((check)=>{
+            var _check_output_title, _check_output;
+            return check.name.toLowerCase().includes('test') || check.name.toLowerCase().includes('ci') || ((_check_output = check.output) === null || _check_output === void 0 ? void 0 : (_check_output_title = _check_output.title) === null || _check_output_title === void 0 ? void 0 : _check_output_title.toLowerCase().includes('test'));
+        });
+        const lintFailures = this.failedChecks.filter((check)=>{
+            var _check_output_title, _check_output;
+            return check.name.toLowerCase().includes('lint') || check.name.toLowerCase().includes('style') || ((_check_output = check.output) === null || _check_output === void 0 ? void 0 : (_check_output_title = _check_output.title) === null || _check_output_title === void 0 ? void 0 : _check_output_title.toLowerCase().includes('lint'));
+        });
+        const buildFailures = this.failedChecks.filter((check)=>{
+            var _check_output_title, _check_output;
+            return check.name.toLowerCase().includes('build') || check.name.toLowerCase().includes('compile') || ((_check_output = check.output) === null || _check_output === void 0 ? void 0 : (_check_output_title = _check_output.title) === null || _check_output_title === void 0 ? void 0 : _check_output_title.toLowerCase().includes('build'));
+        });
+        instructions.push('🔧 To fix these failures:');
+        instructions.push('');
+        // Specific instructions based on failure types
+        if (testFailures.length > 0) {
+            instructions.push('📋 Test Failures:');
+            instructions.push('   • Run tests locally: `npm test` or `yarn test`');
+            instructions.push('   • Fix failing tests or update test expectations');
+            instructions.push('   • Consider running specific test files if identified in the failure details');
+            instructions.push('');
+        }
+        if (lintFailures.length > 0) {
+            instructions.push('🎨 Linting/Style Failures:');
+            instructions.push('   • Run linter locally: `npm run lint` or `yarn lint`');
+            instructions.push('   • Auto-fix where possible: `npm run lint:fix` or `yarn lint:fix`');
+            instructions.push('   • Check code formatting: `npm run format` or `yarn format`');
+            instructions.push('');
+        }
+        if (buildFailures.length > 0) {
+            instructions.push('🏗️ Build Failures:');
+            instructions.push('   • Run build locally: `npm run build` or `yarn build`');
+            instructions.push('   • Check for TypeScript errors: `npx tsc --noEmit`');
+            instructions.push('   • Review dependency issues and import paths');
+            instructions.push('');
+        }
+        // General workflow instructions
+        instructions.push('📤 After fixing the issues:');
+        instructions.push(`   1. Stage your changes: \`git add .\``);
+        instructions.push(`   2. Commit your fixes: \`git commit -m "fix: resolve PR check failures"\``);
+        instructions.push(`   3. Push to ${branchName}: \`git push origin ${branchName}\``);
+        instructions.push(`   4. The PR checks will automatically re-run`);
+        instructions.push('');
+        instructions.push('🔄 Re-running this command:');
+        instructions.push('   • The kodrdriv publish command will automatically detect the existing PR');
+        instructions.push('   • Simply run the same command again after pushing your fixes');
+        instructions.push('   • You can also manually trigger checks by pushing an empty commit:');
+        instructions.push(`     \`git commit --allow-empty -m "trigger checks" && git push origin ${branchName}\``);
+        return instructions;
+    }
+    constructor(message, prNumber, failedChecks, prUrl, currentBranch){
+        super(message, 'PR_CHECK_FAILED', true), _define_property(this, "prNumber", void 0), _define_property(this, "failedChecks", void 0), _define_property(this, "prUrl", void 0), _define_property(this, "currentBranch", void 0), this.prNumber = prNumber, this.failedChecks = failedChecks, this.prUrl = prUrl, this.currentBranch = currentBranch;
+        this.name = 'PullRequestCheckError';
+    }
+}
+
+class ExitError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'ExitError';
+    }
+}
+
+const create$1 = ()=>{
+    const logger = getLogger();
+    const exists = async (path)=>{
+        try {
+            await fs.promises.stat(path);
+            return true;
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        } catch (error) {
+            return false;
+        }
+    };
+    const isDirectory = async (path)=>{
+        const stats = await fs.promises.stat(path);
+        if (!stats.isDirectory()) {
+            // Log at debug level since this is expected when scanning directories
+            // that contain both files and directories
+            return false;
+        }
+        return true;
+    };
+    const isFile = async (path)=>{
+        const stats = await fs.promises.stat(path);
+        if (!stats.isFile()) {
+            // Log removed since this is expected when checking file types
+            return false;
+        }
+        return true;
+    };
+    const isReadable = async (path)=>{
+        try {
+            await fs.promises.access(path, fs.constants.R_OK);
+        } catch (error) {
+            logger.debug(`${path} is not readable: ${error.message}`);
+            return false;
+        }
+        return true;
+    };
+    const isWritable = async (path)=>{
+        try {
+            await fs.promises.access(path, fs.constants.W_OK);
+        } catch (error) {
+            logger.debug(`${path} is not writable: ${error.message}`);
+            return false;
+        }
+        return true;
+    };
+    const isFileReadable = async (path)=>{
+        return await exists(path) && await isFile(path) && await isReadable(path);
+    };
+    const isDirectoryWritable = async (path)=>{
+        return await exists(path) && await isDirectory(path) && await isWritable(path);
+    };
+    const isDirectoryReadable = async (path)=>{
+        return await exists(path) && await isDirectory(path) && await isReadable(path);
+    };
+    const createDirectory = async (path)=>{
+        try {
+            await fs.promises.mkdir(path, {
+                recursive: true
+            });
+        } catch (mkdirError) {
+            throw new Error(`Failed to create output directory ${path}: ${mkdirError.message} ${mkdirError.stack}`);
+        }
+    };
+    const ensureDirectory = async (path)=>{
+        if (!await exists(path)) {
+            // Before creating the directory, check if any parent directory is blocked by a file
+            try {
+                await fs.promises.mkdir(path, {
+                    recursive: true
+                });
+            } catch (mkdirError) {
+                // If mkdir fails with ENOTDIR, it means a parent directory is actually a file
+                if (mkdirError.code === 'ENOTDIR') {
+                    // Find which parent directory is the problem
+                    const pathParts = path.split('/').filter((p)=>p !== '');
+                    let currentPath = '';
+                    for (const part of pathParts){
+                        currentPath = currentPath ? `${currentPath}/${part}` : part;
+                        if (await exists(currentPath) && !await isDirectory(currentPath)) {
+                            throw new Error(`Cannot create directory at ${path}: a file exists at ${currentPath} blocking the path`);
+                        }
+                    }
+                }
+                // Re-throw the original error if it's not the file-blocking-path issue or we couldn't find the blocking file
+                throw new Error(`Failed to create output directory ${path}: ${mkdirError.message} ${mkdirError.stack}`);
+            }
+        } else {
+            // Path exists, but we need to check if it's actually a directory
+            if (!await isDirectory(path)) {
+                // Path exists but is not a directory (likely a file)
+                throw new Error(`Cannot create directory at ${path}: a file already exists at this location`);
+            }
+        // If we reach here, the directory already exists, so nothing to do
+        }
+    };
+    const removeDirectory = async (path)=>{
+        try {
+            if (await exists(path)) {
+                await fs.promises.rm(path, {
+                    recursive: true,
+                    force: true
+                });
+            }
+        } catch (rmError) {
+            throw new Error(`Failed to remove directory ${path}: ${rmError.message} ${rmError.stack}`);
+        }
+    };
+    const readFile = async (path, encoding)=>{
+        return await fs.promises.readFile(path, {
+            encoding: encoding
+        });
+    };
+    const writeFile = async (path, data, encoding)=>{
+        await fs.promises.writeFile(path, data, {
+            encoding: encoding
+        });
+    };
+    const rename = async (oldPath, newPath)=>{
+        await fs.promises.rename(oldPath, newPath);
+    };
+    const deleteFile = async (path)=>{
+        try {
+            if (await exists(path)) {
+                await fs.promises.unlink(path);
+            }
+        } catch (deleteError) {
+            throw new Error(`Failed to delete file ${path}: ${deleteError.message} ${deleteError.stack}`);
+        }
+    };
+    const forEachFileIn = async (directory, callback, options = {
+        pattern: '*.*'
+    })=>{
+        try {
+            const files = await glob(options.pattern, {
+                cwd: directory,
+                nodir: true
+            });
+            for (const file of files){
+                await callback(path.join(directory, file));
+            }
+        } catch (err) {
+            throw new Error(`Failed to glob pattern ${options.pattern} in ${directory}: ${err.message}`);
+        }
+    };
+    const readStream = async (path)=>{
+        return fs.createReadStream(path);
+    };
+    const hashFile = async (path, length)=>{
+        const file = await readFile(path, 'utf8');
+        return crypto.createHash('sha256').update(file).digest('hex').slice(0, length);
+    };
+    const listFiles = async (directory)=>{
+        return await fs.promises.readdir(directory);
+    };
+    return {
+        exists,
+        isDirectory,
+        isFile,
+        isReadable,
+        isWritable,
+        isFileReadable,
+        isDirectoryWritable,
+        isDirectoryReadable,
+        createDirectory,
+        ensureDirectory,
+        readFile,
+        readStream,
+        writeFile,
+        rename,
+        deleteFile,
+        forEachFileIn,
+        hashFile,
+        listFiles,
+        removeDirectory
+    };
+};
+
+// Function to read from STDIN if available
+async function readStdin() {
+    // In test environment, allow mocking to work by skipping TTY check
+    if (process.env.NODE_ENV === 'test' || process.env.VITEST === 'true') {
+        return new Promise((resolve)=>{
+            let input = '';
+            let hasData = false;
+            let resolved = false;
+            const timeout = setTimeout(()=>{
+                if (!hasData && !resolved) {
+                    resolved = true;
+                    cleanup();
+                    resolve(null);
+                }
+            }, 10); // Very short timeout for tests
+            const onData = (chunk)=>{
+                hasData = true;
+                clearTimeout(timeout);
+                input += chunk;
+            };
+            const onEnd = ()=>{
+                if (!resolved) {
+                    resolved = true;
+                    cleanup();
+                    resolve(input.trim() || null);
+                }
+            };
+            const onError = ()=>{
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    cleanup();
+                    resolve(null);
+                }
+            };
+            const cleanup = ()=>{
+                process.stdin.removeListener('data', onData);
+                process.stdin.removeListener('end', onEnd);
+                process.stdin.removeListener('error', onError);
+                process.stdin.pause();
+            };
+            process.stdin.setEncoding('utf8');
+            process.stdin.on('data', onData);
+            process.stdin.on('end', onEnd);
+            process.stdin.on('error', onError);
+            process.stdin.resume();
+        });
+    }
+    return new Promise((resolve)=>{
+        // Check if stdin is TTY (interactive terminal)
+        if (process.stdin.isTTY) {
+            resolve(null);
+            return;
+        }
+        let input = '';
+        let hasData = false;
+        let resolved = false;
+        const timeout = setTimeout(()=>{
+            if (!hasData && !resolved) {
+                resolved = true;
+                cleanup();
+                resolve(null);
+            }
+        }, 100); // Short timeout to detect if data is available
+        const onData = (chunk)=>{
+            hasData = true;
+            clearTimeout(timeout);
+            input += chunk;
+        };
+        const onEnd = ()=>{
+            if (!resolved) {
+                resolved = true;
+                cleanup();
+                resolve(input.trim() || null);
+            }
+        };
+        const onError = ()=>{
+            if (!resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                cleanup();
+                resolve(null);
+            }
+        };
+        const cleanup = ()=>{
+            process.stdin.removeListener('data', onData);
+            process.stdin.removeListener('end', onEnd);
+            process.stdin.removeListener('error', onError);
+            process.stdin.pause();
+        };
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', onData);
+        process.stdin.on('end', onEnd);
+        process.stdin.on('error', onError);
+        // If no data comes in quickly, assume no stdin
+        process.stdin.resume();
+    });
+}
+// Function to prompt user for confirmation (y/n)
+async function promptConfirmation(message) {
+    // In test environment, return true by default
+    if (process.env.NODE_ENV === 'test' || process.env.VITEST === 'true') {
+        return true;
+    }
+    // Use process.stdout.write instead of console.log to avoid linter issues
+    process.stdout.write(message + '\n');
+    process.stdout.write('Please enter "y" for yes or "n" for no: ');
+    return new Promise((resolve)=>{
+        const handleInput = (chunk)=>{
+            const input = chunk.toString().trim().toLowerCase();
+            if (input === 'y' || input === 'yes') {
+                cleanup();
+                resolve(true);
+            } else if (input === 'n' || input === 'no') {
+                cleanup();
+                resolve(false);
+            } else {
+                process.stdout.write('Please enter "y" for yes or "n" for no: ');
+            // Continue listening for input
+            }
+        };
+        const cleanup = ()=>{
+            process.stdin.removeListener('data', handleInput);
+            process.stdin.pause();
+        };
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', handleInput);
+        process.stdin.resume();
+    });
+}
+
+dayjs.extend(utc);
+dayjs.extend(timezone);
+const create = (parameters)=>{
+    const { timezone } = parameters;
+    const now = ()=>{
+        return date(undefined);
+    };
+    const date = (date)=>{
+        let value;
+        if (date) {
+            value = dayjs.tz(date, timezone);
+        } else {
+            value = dayjs().tz(timezone);
+        }
+        if (!value.isValid()) {
+            throw new Error(`Invalid date: ${date}`);
+        }
+        return value.toDate();
+    };
+    const parse = (date, format)=>{
+        const value = dayjs.tz(date, format, timezone);
+        if (!value.isValid()) {
+            throw new Error(`Invalid date: ${date}, expected format: ${format}`);
+        }
+        return value.toDate();
+    };
+    const addDays = (date, days)=>{
+        return dayjs.tz(date, timezone).add(days, 'day').toDate();
+    };
+    const addMonths = (date, months)=>{
+        return dayjs.tz(date, timezone).add(months, 'month').toDate();
+    };
+    const addYears = (date, years)=>{
+        return dayjs.tz(date, timezone).add(years, 'year').toDate();
+    };
+    const format = (date, format)=>{
+        return dayjs.tz(date, timezone).format(format);
+    };
+    const subDays = (date, days)=>{
+        return dayjs.tz(date, timezone).subtract(days, 'day').toDate();
+    };
+    const subMonths = (date, months)=>{
+        return dayjs.tz(date, timezone).subtract(months, 'month').toDate();
+    };
+    const subYears = (date, years)=>{
+        return dayjs.tz(date, timezone).subtract(years, 'year').toDate();
+    };
+    const startOfMonth = (date)=>{
+        return dayjs.tz(date, timezone).startOf('month').toDate();
+    };
+    const endOfMonth = (date)=>{
+        return dayjs.tz(date, timezone).endOf('month').toDate();
+    };
+    const startOfYear = (date)=>{
+        return dayjs.tz(date, timezone).startOf('year').toDate();
+    };
+    const endOfYear = (date)=>{
+        return dayjs.tz(date, timezone).endOf('year').toDate();
+    };
+    const isBefore = (date, other)=>{
+        return dayjs.tz(date, timezone).isBefore(dayjs.tz(other, timezone));
+    };
+    const isAfter = (date, other)=>{
+        return dayjs.tz(date, timezone).isAfter(dayjs.tz(other, timezone));
+    };
+    return {
+        now,
+        date,
+        parse,
+        addDays,
+        addMonths,
+        addYears,
+        format,
+        subDays,
+        subMonths,
+        subYears,
+        startOfMonth,
+        endOfMonth,
+        startOfYear,
+        endOfYear,
+        isBefore,
+        isAfter
+    };
+};
+const validTimezones = ()=>{
+    return moment.tz.names();
+};
+
+/**
+ * General utility functions
+ */ // Utility function for deep merging two objects.
+function deepMerge(target, source) {
+    for(const key in source){
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            if (key === "__proto__" || key === "constructor") {
+                continue; // Skip prototype-polluting keys
+            }
+            if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+                if (!target[key]) {
+                    target[key] = {};
+                }
+                deepMerge(target[key], source[key]);
+            } else {
+                target[key] = source[key];
+            }
+        }
+    }
+    return target;
+}
+// Recursive implementation of JSON.stringify
+const stringifyJSON = function(obj, options = {
+    depth: 0
+}) {
+    if (options.depth > 10) {
+        return '{"error": "Maximum depth reached"}';
+    }
+    const arrOfKeyVals = [];
+    const arrVals = [];
+    let objKeys = [];
+    /*********CHECK FOR PRIMITIVE TYPES**********/ if (typeof obj === 'number' || typeof obj === 'boolean' || obj === null) return '' + obj;
+    else if (typeof obj === 'string') return '"' + obj + '"';
+    else if (Array.isArray(obj)) {
+        //check for empty array
+        if (obj[0] === undefined) return '[]';
+        else {
+            obj.forEach(function(el) {
+                arrVals.push(stringifyJSON(el, {
+                    depth: options.depth + 1
+                }));
+            });
+            return '[' + arrVals + ']';
+        }
+    } else if (obj instanceof Object) {
+        //get object keys
+        objKeys = Object.keys(obj);
+        //set key output;
+        objKeys.forEach(function(key) {
+            const keyOut = '"' + key + '":';
+            const keyValOut = obj[key];
+            //skip functions and undefined properties
+            if (keyValOut instanceof Function || keyValOut === undefined) arrOfKeyVals.push('');
+            else if (typeof keyValOut === 'string') arrOfKeyVals.push(keyOut + '"' + keyValOut + '"');
+            else if (typeof keyValOut === 'boolean' || typeof keyValOut === 'number' || keyValOut === null) arrOfKeyVals.push(keyOut + keyValOut);
+            else if (keyValOut instanceof Object) {
+                arrOfKeyVals.push(keyOut + stringifyJSON(keyValOut, {
+                    depth: options.depth + 1
+                }));
+            }
+        });
+        return '{' + arrOfKeyVals + '}';
+    }
+    return '';
+};
+// Version increment functions
+const incrementPatchVersion = (version)=>{
+    // Remove 'v' prefix if present
+    const cleanVersion = version.startsWith('v') ? version.slice(1) : version;
+    // Split into major.minor.patch and handle pre-release identifiers
+    const parts = cleanVersion.split('.');
+    if (parts.length < 3) {
+        throw new Error(`Invalid version string: ${version}`);
+    }
+    // Handle pre-release versions like "4.6.24-dev.0"
+    // Split the patch part on '-' to separate patch number from pre-release
+    const patchPart = parts[2];
+    let patchNumber;
+    if (patchPart.startsWith('-')) {
+        // Handle negative patch numbers like "-1" or "-5" or "-1-dev.0"
+        const negativeComponents = patchPart.split('-');
+        if (negativeComponents.length === 2) {
+            // "-1" format
+            patchNumber = parseInt(negativeComponents[1]);
+        } else if (negativeComponents.length > 2) {
+            // "-1-dev.0" format - take the number after first dash
+            patchNumber = parseInt(negativeComponents[1]);
+        } else {
+            throw new Error(`Invalid version string: ${version}`);
+        }
+    } else if (patchPart.includes('-')) {
+        // Normal case with possible prerelease: "24-dev.0" or "24"
+        const patchComponents = patchPart.split('-');
+        patchNumber = parseInt(patchComponents[0]);
+    } else {
+        // Simple patch number: "24"
+        patchNumber = parseInt(patchPart);
+    }
+    if (isNaN(patchNumber)) {
+        throw new Error(`Invalid patch number in version: ${version}`);
+    }
+    const incrementedPatch = patchNumber + 1;
+    return `${parts[0]}.${parts[1]}.${incrementedPatch}`;
+};
+const incrementMinorVersion = (version)=>{
+    // Remove 'v' prefix if present
+    const cleanVersion = version.startsWith('v') ? version.slice(1) : version;
+    const parts = cleanVersion.split('.');
+    if (parts.length < 3) {
+        throw new Error(`Invalid version string: ${version}`);
+    }
+    const major = parts[0];
+    const minor = parseInt(parts[1]);
+    if (isNaN(minor)) {
+        throw new Error(`Invalid minor version in: ${version}`);
+    }
+    return `${major}.${minor + 1}.0`;
+};
+const incrementMajorVersion = (version)=>{
+    // Remove 'v' prefix if present
+    const cleanVersion = version.startsWith('v') ? version.slice(1) : version;
+    const parts = cleanVersion.split('.');
+    if (parts.length < 3) {
+        throw new Error(`Invalid version string: ${version}`);
+    }
+    const major = parseInt(parts[0]);
+    if (isNaN(major)) {
+        throw new Error(`Invalid major version in: ${version}`);
+    }
+    return `${major + 1}.0.0`;
+};
+const validateVersionString = (version)=>{
+    // Simple validation: x.y.z format (with optional v prefix)
+    const cleanVersion = version.startsWith('v') ? version.slice(1) : version;
+    return /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/.test(cleanVersion);
+};
+const calculateTargetVersion = (currentVersion, targetVersion)=>{
+    switch(targetVersion){
+        case 'patch':
+            return incrementPatchVersion(currentVersion);
+        case 'minor':
+            return incrementMinorVersion(currentVersion);
+        case 'major':
+            return incrementMajorVersion(currentVersion);
+        default:
+            // Explicit version provided
+            if (!validateVersionString(targetVersion)) {
+                throw new Error(`Invalid version format: ${targetVersion}. Expected format: "x.y.z" or one of: "patch", "minor", "major"`);
+            }
+            return targetVersion.startsWith('v') ? targetVersion.slice(1) : targetVersion;
+    }
+};
+const incrementPrereleaseVersion = (version, tag)=>{
+    const cleanVersion = version.startsWith('v') ? version.slice(1) : version;
+    // Split on dots but only use first 3 parts for major.minor.patch
+    // This handles cases like "1.2.3-dev.5" correctly
+    const dotParts = cleanVersion.split('.');
+    if (dotParts.length < 3) {
+        throw new Error(`Invalid version string: ${version}`);
+    }
+    const major = dotParts[0];
+    const minor = dotParts[1];
+    // Reconstruct the patch part - everything after the second dot
+    const patchAndPrerelease = dotParts.slice(2).join('.');
+    const patchComponents = patchAndPrerelease.split('-');
+    const patchNumber = patchComponents[0];
+    if (patchComponents.length > 1) {
+        // Already has prerelease (e.g., "3-dev.0" or "3-test.2")
+        const prereleaseString = patchComponents.slice(1).join('-'); // Handle multiple dashes
+        const prereleaseComponents = prereleaseString.split('.');
+        const existingTag = prereleaseComponents[0];
+        const existingPrereleaseVersion = prereleaseComponents[1];
+        if (existingTag === tag) {
+            // Same tag, increment the prerelease version
+            const prereleaseNumber = parseInt(existingPrereleaseVersion) || 0;
+            return `${major}.${minor}.${patchNumber}-${tag}.${prereleaseNumber + 1}`;
+        } else {
+            // Different tag, start at 0
+            return `${major}.${minor}.${patchNumber}-${tag}.0`;
+        }
+    } else {
+        // No prerelease yet, add it
+        return `${major}.${minor}.${patchNumber}-${tag}.0`;
+    }
+};
+const convertToReleaseVersion = (version)=>{
+    const cleanVersion = version.startsWith('v') ? version.slice(1) : version;
+    // Split on dots but only use first 3 parts for major.minor.patch
+    const dotParts = cleanVersion.split('.');
+    if (dotParts.length < 3) {
+        throw new Error(`Invalid version string: ${version}`);
+    }
+    const major = dotParts[0];
+    const minor = dotParts[1];
+    // Reconstruct the patch part - everything after the second dot
+    const patchAndPrerelease = dotParts.slice(2).join('.');
+    const patchComponents = patchAndPrerelease.split('-');
+    const patchNumber = patchComponents[0];
+    return `${major}.${minor}.${patchNumber}`;
+};
+// Async utility functions
+const sleep = (ms)=>{
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+};
+const retryWithBackoff = async (fn, maxRetries = 3, initialDelay = 1000)=>{
+    let lastError;
+    for(let i = 0; i < maxRetries; i++){
+        try {
+            return await fn();
+        } catch (error) {
+            lastError = error;
+            if (i < maxRetries - 1) {
+                const delay = initialDelay * Math.pow(2, i);
+                await sleep(delay);
+            }
+        }
+    }
+    throw lastError || new Error('Retry failed');
+};
+// Array utilities
+const uniqueArray = (array)=>{
+    return Array.from(new Set(array));
+};
+const groupBy = (array, key)=>{
+    return array.reduce((result, item)=>{
+        const groupKey = String(item[key]);
+        if (!result[groupKey]) {
+            result[groupKey] = [];
+        }
+        result[groupKey].push(item);
+        return result;
+    }, {});
+};
+// String utilities
+const truncateString = (str, maxLength, suffix = '...')=>{
+    if (str.length <= maxLength) {
+        return str;
+    }
+    return str.substring(0, maxLength - suffix.length) + suffix;
+};
+// JSON utilities
+const safeJsonParse = (jsonString, fallback)=>{
+    try {
+        return JSON.parse(jsonString);
+    } catch  {
+        return fallback !== undefined ? fallback : null;
+    }
+};
+
+const EXCLUDED_DIRECTORIES = [
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    '.git',
+    '.next',
+    '.nuxt',
+    'out',
+    'public',
+    'static',
+    'assets'
+];
+const findAllPackageJsonFiles = async (rootDir, storage)=>{
+    const logger = getLogger();
+    const packageJsonFiles = [];
+    const scanDirectory = async (currentDir, depth = 0)=>{
+        // Prevent infinite recursion and overly deep scanning
+        if (depth > 5) {
+            return;
+        }
+        try {
+            if (!await storage.exists(currentDir) || !await storage.isDirectory(currentDir)) {
+                return;
+            }
+            const items = await storage.listFiles(currentDir);
+            // Check for package.json in current directory
+            if (items.includes('package.json')) {
+                const packageJsonPath = path.join(currentDir, 'package.json');
+                try {
+                    const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+                    const parsed = safeJsonParse$1(packageJsonContent, packageJsonPath);
+                    const packageJson = validatePackageJson(parsed, packageJsonPath);
+                    const relativePath = path.relative(rootDir, currentDir);
+                    packageJsonFiles.push({
+                        path: packageJsonPath,
+                        packageJson,
+                        relativePath: relativePath || '.'
+                    });
+                    logger.debug(`Found package.json at: ${relativePath || '.'}`);
+                } catch (error) {
+                    logger.debug(`Skipped invalid package.json at ${packageJsonPath}: ${error.message}`);
+                }
+            }
+            // Scan subdirectories, excluding build/generated directories
+            for (const item of items){
+                if (EXCLUDED_DIRECTORIES.includes(item)) {
+                    continue;
+                }
+                const itemPath = path.join(currentDir, item);
+                try {
+                    if (await storage.isDirectory(itemPath)) {
+                        await scanDirectory(itemPath, depth + 1);
+                    }
+                } catch (error) {
+                    // Skip directories that can't be accessed
+                    logger.debug(`Skipped directory ${itemPath}: ${error.message}`);
+                    continue;
+                }
+            }
+        } catch (error) {
+            logger.debug(`Failed to scan directory ${currentDir}: ${error.message}`);
+        }
+    };
+    await scanDirectory(rootDir);
+    logger.debug(`Found ${packageJsonFiles.length} package.json file(s) in directory tree`);
+    return packageJsonFiles;
+};
+/**
+ * Checks for file: dependencies in package.json files that should not be committed
+ * @param storage Storage utility instance
+ * @param rootDir Root directory to scan (defaults to current working directory)
+ * @returns Array of issues found, empty array if no issues
+ */ const checkForFileDependencies = async (storage, rootDir = process.cwd())=>{
+    const logger = getLogger();
+    const issues = [];
+    try {
+        const packageJsonFiles = await findAllPackageJsonFiles(rootDir, storage);
+        for (const { packageJson, relativePath } of packageJsonFiles){
+            const fileDeps = [];
+            // Check all dependency types for file: paths
+            const dependencyChecks = [
+                {
+                    deps: packageJson.dependencies,
+                    type: 'dependencies'
+                },
+                {
+                    deps: packageJson.devDependencies,
+                    type: 'devDependencies'
+                },
+                {
+                    deps: packageJson.peerDependencies,
+                    type: 'peerDependencies'
+                }
+            ];
+            for (const { deps, type } of dependencyChecks){
+                if (deps) {
+                    for (const [name, version] of Object.entries(deps)){
+                        if (version.startsWith('file:')) {
+                            fileDeps.push({
+                                name,
+                                version,
+                                dependencyType: type
+                            });
+                        }
+                    }
+                }
+            }
+            if (fileDeps.length > 0) {
+                issues.push({
+                    packagePath: relativePath,
+                    dependencies: fileDeps
+                });
+            }
+        }
+    } catch (error) {
+        logger.debug(`Failed to check for file dependencies: ${error.message}`);
+    }
+    return issues;
+};
+/**
+ * Logs file dependency issues in a user-friendly format
+ * @param issues Array of file dependency issues
+ * @param context Context for the warning (e.g., 'commit', 'link check')
+ */ const logFileDependencyWarning = (issues, context = 'operation')=>{
+    const logger = getLogger();
+    if (issues.length === 0) {
+        return;
+    }
+    logger.warn(`FILE_DEPS_WARNING: Found file: dependencies that should not be committed | Context: ${context} | Count: ${issues.length} | Impact: May cause build issues`);
+    for (const issue of issues){
+        logger.warn(`FILE_DEPS_PACKAGE: Package with file dependencies | Package: ${issue.packagePath}`);
+        for (const dep of issue.dependencies){
+            logger.warn(`FILE_DEPS_DETAIL: Dependency details | Name: ${dep.name} | Version: ${dep.version} | Type: ${dep.dependencyType}`);
+        }
+    }
+    logger.warn('');
+};
+/**
+ * Provides suggestions for resolving file dependency issues
+ * @param hasUnlinkCapability Whether the current context supports unlinking
+ */ const logFileDependencySuggestions = (hasUnlinkCapability = true)=>{
+    const logger = getLogger();
+    logger.warn('FILE_DEPS_RESOLUTION: Steps to resolve file dependency issues:');
+    if (hasUnlinkCapability) {
+        logger.warn('   STEP_1: Restore registry versions | Command: kodrdriv unlink');
+        logger.warn('   STEP_2: Complete commit operation | Command: git commit');
+        logger.warn('   STEP_3: Restore local development links | Command: kodrdriv link');
+    } else {
+        logger.warn('   STEP_1: Manually restore registry versions in package.json files');
+        logger.warn('   STEP_2: Complete commit operation | Command: git commit');
+        logger.warn('   STEP_3: Re-link local dependencies for development');
+    }
+    logger.warn('');
+    logger.warn('FILE_DEPS_BYPASS: Alternative bypass options:');
+    logger.warn('   OPTION_1: Skip file check | Flag: --skip-file-check');
+    logger.warn('   OPTION_2: Skip all hooks | Command: git commit --no-verify');
+    logger.warn('');
+};
+
+/**
+ * Runtime validation utilities for safe type handling
+ */ /**
+ * Generic validation function that validates data against a schema
+ * @param data Data to validate
+ * @param schema Validation schema (can be a Zod schema or custom validator)
+ * @returns ValidationResult with success status and either data or error
+ */ const validate = (data, schema)=>{
+    try {
+        const validated = schema.parse(data);
+        return {
+            success: true,
+            data: validated
+        };
+    } catch (error) {
+        return {
+            success: false,
+            error: String(error)
+        };
+    }
+};
+/**
+ * Validates that a value is a string
+ */ const validateString = (value, fieldName = 'value')=>{
+    if (typeof value !== 'string') {
+        throw new Error(`${fieldName} must be a string`);
+    }
+    return value;
+};
+/**
+ * Validates that a value is a number
+ */ const validateNumber = (value, fieldName = 'value')=>{
+    if (typeof value !== 'number' || isNaN(value)) {
+        throw new Error(`${fieldName} must be a valid number`);
+    }
+    return value;
+};
+/**
+ * Validates that a value is a boolean
+ */ const validateBoolean = (value, fieldName = 'value')=>{
+    if (typeof value !== 'boolean') {
+        throw new Error(`${fieldName} must be a boolean`);
+    }
+    return value;
+};
+/**
+ * Validates that a value is an array
+ */ const validateArray = (value, fieldName = 'value')=>{
+    if (!Array.isArray(value)) {
+        throw new Error(`${fieldName} must be an array`);
+    }
+    return value;
+};
+/**
+ * Validates that a value is an object (and not null or array)
+ */ const validateObject = (value, fieldName = 'value')=>{
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error(`${fieldName} must be an object`);
+    }
+    return value;
+};
+/**
+ * Validates that a string is not empty
+ */ const validateNonEmptyString = (value, fieldName = 'value')=>{
+    const str = validateString(value, fieldName);
+    if (str.trim().length === 0) {
+        throw new Error(`${fieldName} must not be empty`);
+    }
+    return str;
+};
+/**
+ * Validates that a value is one of the allowed values
+ */ const validateEnum = (value, allowedValues, fieldName = 'value')=>{
+    if (!allowedValues.includes(value)) {
+        throw new Error(`${fieldName} must be one of: ${allowedValues.join(', ')}. Got: ${value}`);
+    }
+    return value;
+};
+
+export { ArgumentError, CancellationError, CommandError, ConfigurationError, ExitError, ExternalDependencyError, FileOperationError, PullRequestCheckError, UserCancellationError, ValidationError, calculateTargetVersion, checkForFileDependencies, convertToReleaseVersion, create as createDateUtility, create$1 as createStorage, deepMerge, getLogger, groupBy, incrementMajorVersion, incrementMinorVersion, incrementPatchVersion, incrementPrereleaseVersion, logFileDependencySuggestions, logFileDependencyWarning, promptConfirmation, readStdin, retryWithBackoff, safeJsonParse, setLogger, sleep, stringifyJSON, truncateString, uniqueArray, validTimezones, validate, validateArray, validateBoolean, validateEnum, validateNonEmptyString, validateNumber, validateObject, validateString, validateVersionString };
+//# sourceMappingURL=index.js.map