@eldrforge/git-tools 0.1.7 → 0.1.10

package/dist/index.js

@@ -1,5 +1,1401 @@
-export { ConsoleLogger, getLogger, setLogger } from './logger.js';
-export { escapeShellArg, run, runSecure, runSecureWithDryRunSupport, runSecureWithInheritedStdio, runWithDryRunSupport, runWithInheritedStdio, validateFilePath, validateGitRef } from './child.js';
-export { safeJsonParse, validateHasProperty, validatePackageJson, validateString } from './validation.js';
-export { findPreviousReleaseTag, getBranchCommitSha, getCurrentBranch, getCurrentVersion, getDefaultFromRef, getGitStatusSummary, getGloballyLinkedPackages, getLinkCompatibilityProblems, getLinkProblems, getLinkedDependencies, getRemoteDefaultBranch, isBranchInSyncWithRemote, isNpmLinked, isValidGitRef, localBranchExists, remoteBranchExists, safeSyncBranchWithRemote } from './git.js';
+import { spawn, exec } from 'child_process';
+import util from 'util';
+import fs from 'fs/promises';
+import path from 'path';
+import * as semver from 'semver';
+
+/**
+ * Minimal logging interface that git-tools requires.
+ * Allows consumers to provide their own logger implementation (e.g., Winston, console, etc.)
+ */ 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;
+}
+/**
+ * Default console-based logger implementation
+ */ class ConsoleLogger {
+    shouldLog(level) {
+        const levels = [
+            'error',
+            'warn',
+            'info',
+            'verbose',
+            'debug'
+        ];
+        const currentLevelIndex = levels.indexOf(this.level);
+        const messageLevelIndex = levels.indexOf(level);
+        return messageLevelIndex <= currentLevelIndex;
+    }
+    error(message, ...meta) {
+        if (this.shouldLog('error')) {
+            // eslint-disable-next-line no-console
+            console.error(message, ...meta);
+        }
+    }
+    warn(message, ...meta) {
+        if (this.shouldLog('warn')) {
+            // eslint-disable-next-line no-console
+            console.warn(message, ...meta);
+        }
+    }
+    info(message, ...meta) {
+        if (this.shouldLog('info')) {
+            // eslint-disable-next-line no-console
+            console.info(message, ...meta);
+        }
+    }
+    verbose(message, ...meta) {
+        if (this.shouldLog('verbose')) {
+            // eslint-disable-next-line no-console
+            console.log('[VERBOSE]', message, ...meta);
+        }
+    }
+    debug(message, ...meta) {
+        if (this.shouldLog('debug')) {
+            // eslint-disable-next-line no-console
+            console.log('[DEBUG]', message, ...meta);
+        }
+    }
+    constructor(level = 'info'){
+        _define_property(this, "level", void 0);
+        this.level = level;
+    }
+}
+/**
+ * Global logger instance - defaults to console logger
+ * Use setLogger() to replace with your own implementation
+ */ let globalLogger = new ConsoleLogger();
+/**
+ * Set the global logger instance
+ */ function setLogger(logger) {
+    globalLogger = logger;
+}
+/**
+ * Get the global logger instance
+ */ function getLogger() {
+    return globalLogger;
+}
+
+/**
+ * Escapes shell arguments to prevent command injection
+ */ function escapeShellArg(arg) {
+    // For Windows, we need different escaping
+    if (process.platform === 'win32') {
+        // Escape double quotes and backslashes
+        return `"${arg.replace(/[\\"]/g, '\\$&')}"`;
+    } else {
+        // For Unix-like systems, escape single quotes
+        return `'${arg.replace(/'/g, "'\\''")}'`;
+    }
+}
+/**
+ * Validates git references to prevent injection
+ */ function validateGitRef(ref) {
+    // Git refs can contain letters, numbers, hyphens, underscores, slashes, and dots
+    // But cannot contain certain dangerous characters
+    const validRefPattern = /^[a-zA-Z0-9._/-]+$/;
+    const invalidPatterns = [
+        /\.\./,
+        /^-/,
+        /[\s;<>|&`$(){}[\]]/ // No shell metacharacters
+    ];
+    if (!validRefPattern.test(ref)) {
+        return false;
+    }
+    return !invalidPatterns.some((pattern)=>pattern.test(ref));
+}
+/**
+ * Validates file paths to prevent injection
+ */ function validateFilePath(filePath) {
+    // Basic validation - no shell metacharacters
+    const invalidChars = /[;<>|&`$(){}[\]]/;
+    return !invalidChars.test(filePath);
+}
+/**
+ * Securely executes a command with arguments array (no shell injection risk)
+ */ async function runSecure(command, args = [], options = {}) {
+    const logger = getLogger();
+    // Extract our custom option and pass the rest to spawn
+    const { suppressErrorLogging = false, ...spawnOptions } = options || {};
+    logger.debug(`runSecure: command="${command}" args=[${args.join(', ')}] suppressErrorLogging=${suppressErrorLogging}`);
+    return new Promise((resolve, reject)=>{
+        logger.verbose(`Executing command securely: ${command} ${args.join(' ')}`);
+        logger.verbose(`Working directory: ${(spawnOptions === null || spawnOptions === void 0 ? void 0 : spawnOptions.cwd) || process.cwd()}`);
+        const child = spawn(command, args, {
+            ...spawnOptions,
+            shell: false,
+            stdio: 'pipe'
+        });
+        let stdout = '';
+        let stderr = '';
+        if (child.stdout) {
+            child.stdout.on('data', (data)=>{
+                stdout += data.toString();
+            });
+        }
+        if (child.stderr) {
+            child.stderr.on('data', (data)=>{
+                stderr += data.toString();
+            });
+        }
+        child.on('close', (code)=>{
+            if (code === 0) {
+                logger.verbose(`Command completed successfully`);
+                logger.verbose(`stdout: ${stdout}`);
+                if (stderr) {
+                    logger.verbose(`stderr: ${stderr}`);
+                }
+                resolve({
+                    stdout,
+                    stderr
+                });
+            } else {
+                if (!suppressErrorLogging) {
+                    logger.error(`Command failed with exit code ${code}`);
+                    logger.error(`stdout: ${stdout}`);
+                    logger.error(`stderr: ${stderr}`);
+                }
+                reject(new Error(`Command "${[
+                    command,
+                    ...args
+                ].join(' ')}" failed with exit code ${code}`));
+            }
+        });
+        child.on('error', (error)=>{
+            if (!suppressErrorLogging) {
+                logger.error(`Command failed to start: ${error.message}`);
+            }
+            reject(error);
+        });
+    });
+}
+/**
+ * Securely executes a command with inherited stdio (no shell injection risk)
+ */ async function runSecureWithInheritedStdio(command, args = [], options = {}) {
+    const logger = getLogger();
+    return new Promise((resolve, reject)=>{
+        logger.verbose(`Executing command securely with inherited stdio: ${command} ${args.join(' ')}`);
+        logger.verbose(`Working directory: ${(options === null || options === void 0 ? void 0 : options.cwd) || process.cwd()}`);
+        const child = spawn(command, args, {
+            ...options,
+            shell: false,
+            stdio: 'inherit'
+        });
+        child.on('close', (code)=>{
+            if (code === 0) {
+                logger.verbose(`Command completed successfully with code ${code}`);
+                resolve();
+            } else {
+                logger.error(`Command failed with exit code ${code}`);
+                reject(new Error(`Command "${[
+                    command,
+                    ...args
+                ].join(' ')}" failed with exit code ${code}`));
+            }
+        });
+        child.on('error', (error)=>{
+            logger.error(`Command failed to start: ${error.message}`);
+            reject(error);
+        });
+    });
+}
+async function run(command, options = {}) {
+    const logger = getLogger();
+    const execPromise = util.promisify(exec);
+    // Extract our custom option and pass the rest to exec
+    const { suppressErrorLogging = false, ...execOptions } = options || {};
+    // Ensure encoding is set to 'utf8' to get string output instead of Buffer
+    const finalOptions = {
+        encoding: 'utf8',
+        ...execOptions
+    };
+    logger.debug(`run: command="${command}" suppressErrorLogging=${suppressErrorLogging}`);
+    logger.verbose(`Executing command: ${command}`);
+    logger.verbose(`Working directory: ${(finalOptions === null || finalOptions === void 0 ? void 0 : finalOptions.cwd) || process.cwd()}`);
+    logger.verbose(`Environment variables: ${Object.keys((finalOptions === null || finalOptions === void 0 ? void 0 : finalOptions.env) || process.env).length} variables`);
+    try {
+        const result = await execPromise(command, finalOptions);
+        logger.verbose(`Command completed successfully`);
+        logger.verbose(`stdout: ${result.stdout}`);
+        if (result.stderr) {
+            logger.verbose(`stderr: ${result.stderr}`);
+        }
+        // Ensure result is properly typed as strings
+        return {
+            stdout: String(result.stdout),
+            stderr: String(result.stderr)
+        };
+    } catch (error) {
+        if (!suppressErrorLogging) {
+            logger.error(`Command failed: ${command}`);
+            logger.error(`Error: ${error.message}`);
+            logger.error(`Exit code: ${error.code}`);
+            logger.error(`Signal: ${error.signal}`);
+            if (error.stdout) {
+                logger.error(`stdout: ${error.stdout}`);
+            }
+            if (error.stderr) {
+                logger.error(`stderr: ${error.stderr}`);
+            }
+        } else {
+            // Still log at debug level for troubleshooting
+            logger.debug(`Command failed (suppressed): ${command} | Error: ${error.message}`);
+        }
+        throw error;
+    }
+}
+/**
+ * @deprecated Use runSecureWithInheritedStdio instead for better security
+ * Legacy function for backward compatibility - parses shell command string
+ */ async function runWithInheritedStdio(command, options = {}) {
+    // Parse command to extract command and arguments safely
+    const parts = command.trim().split(/\s+/);
+    if (parts.length === 0) {
+        throw new Error('Empty command provided');
+    }
+    const cmd = parts[0];
+    const args = parts.slice(1);
+    // Use the secure version
+    return runSecureWithInheritedStdio(cmd, args, options);
+}
+async function runWithDryRunSupport(command, isDryRun, options = {}, useInheritedStdio = false) {
+    const logger = getLogger();
+    if (isDryRun) {
+        logger.info(`DRY RUN: Would execute command: ${command}`);
+        return {
+            stdout: '',
+            stderr: ''
+        };
+    }
+    if (useInheritedStdio) {
+        await runWithInheritedStdio(command, options);
+        return {
+            stdout: '',
+            stderr: ''
+        }; // No output captured when using inherited stdio
+    }
+    return run(command, options);
+}
+/**
+ * Secure version of runWithDryRunSupport using argument arrays
+ */ async function runSecureWithDryRunSupport(command, args = [], isDryRun, options = {}, useInheritedStdio = false) {
+    const logger = getLogger();
+    if (isDryRun) {
+        logger.info(`DRY RUN: Would execute command: ${command} ${args.join(' ')}`);
+        return {
+            stdout: '',
+            stderr: ''
+        };
+    }
+    if (useInheritedStdio) {
+        await runSecureWithInheritedStdio(command, args, options);
+        return {
+            stdout: '',
+            stderr: ''
+        }; // No output captured when using inherited stdio
+    }
+    return runSecure(command, args, options);
+}
+
+/**
+ * Runtime validation utilities for safe type handling
+ */ /**
+ * Safely parses JSON with error handling
+ */ const safeJsonParse = (jsonString, context)=>{
+    try {
+        const parsed = JSON.parse(jsonString);
+        if (parsed === null || parsed === undefined) {
+            throw new Error('Parsed JSON is null or undefined');
+        }
+        return parsed;
+    } catch (error) {
+        const contextStr = context ? ` (${context})` : '';
+        throw new Error(`Failed to parse JSON${contextStr}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+};
+/**
+ * Validates that a value is a non-empty string
+ */ const validateString = (value, fieldName)=>{
+    if (typeof value !== 'string') {
+        throw new Error(`${fieldName} must be a string, got ${typeof value}`);
+    }
+    if (value.trim() === '') {
+        throw new Error(`${fieldName} cannot be empty`);
+    }
+    return value;
+};
+/**
+ * Validates that a value exists and has a specific property
+ */ const validateHasProperty = (obj, property, context)=>{
+    if (!obj || typeof obj !== 'object') {
+        const contextStr = context ? ` in ${context}` : '';
+        throw new Error(`Object is null or not an object${contextStr}`);
+    }
+    if (!(property in obj)) {
+        const contextStr = context ? ` in ${context}` : '';
+        throw new Error(`Missing required property '${property}'${contextStr}`);
+    }
+};
+/**
+ * Validates package.json structure has basic required fields
+ */ const validatePackageJson = (data, context, requireName = true)=>{
+    if (!data || typeof data !== 'object') {
+        const contextStr = context ? ` (${context})` : '';
+        throw new Error(`Invalid package.json${contextStr}: not an object`);
+    }
+    if (requireName && typeof data.name !== 'string') {
+        const contextStr = context ? ` (${context})` : '';
+        throw new Error(`Invalid package.json${contextStr}: name must be a string`);
+    }
+    return data;
+};
+
+/**
+ * Validates that a git remote name is safe (prevents option injection).
+ * Git remote names must not start with '-' and should match /^[A-Za-z0-9._\/-]+$/
+ */ function isValidGitRemoteName(remote) {
+    // Disallow starting dash, spaces, and only allow common git remote name characters.
+    // See: https://git-scm.com/docs/git-remote#_remotes
+    return typeof remote === 'string' && remote.length > 0 && !remote.startsWith('-') && /^[A-Za-z0-9._/-]+$/.test(remote);
+}
+/**
+ * Tests if a git reference exists and is valid (silent version that doesn't log errors)
+ */ const isValidGitRefSilent = async (ref)=>{
+    try {
+        // Validate the ref first to prevent injection
+        if (!validateGitRef(ref)) {
+            return false;
+        }
+        await runSecure('git', [
+            'rev-parse',
+            '--verify',
+            ref
+        ], {
+            stdio: 'ignore',
+            suppressErrorLogging: true
+        });
+        return true;
+    } catch  {
+        return false;
+    }
+};
+/**
+ * Tests if a git reference exists and is valid
+ */ const isValidGitRef = async (ref)=>{
+    const logger = getLogger();
+    try {
+        // Validate the ref first to prevent injection
+        if (!validateGitRef(ref)) {
+            logger.debug(`Git reference '${ref}' contains invalid characters`);
+            return false;
+        }
+        await runSecure('git', [
+            'rev-parse',
+            '--verify',
+            ref
+        ], {
+            stdio: 'ignore'
+        });
+        logger.debug(`Git reference '${ref}' is valid`);
+        return true;
+    } catch (error) {
+        logger.debug(`Git reference '${ref}' is not valid: ${error}`);
+        return false;
+    }
+};
+/**
+ * Finds the previous release tag based on the current version using semantic versioning.
+ * Returns the highest version tag that is less than the current version.
+ *
+ * @param currentVersion The current version (e.g., "1.2.3", "2.0.0")
+ * @param tagPattern The pattern to match tags (e.g., "v*", "working/v*")
+ * @returns The previous release tag or null if none found
+ */ const findPreviousReleaseTag = async (currentVersion, tagPattern = 'v*')=>{
+    const logger = getLogger();
+    try {
+        // Parse current version first to validate it
+        const currentSemver = semver.parse(currentVersion);
+        if (!currentSemver) {
+            logger.warn(`❌ Invalid version format: ${currentVersion}`);
+            return null;
+        }
+        logger.info(`🔍 findPreviousReleaseTag: Looking for tags matching "${tagPattern}" < ${currentVersion}`);
+        // Get all tags - try sorted first, fallback to unsorted
+        let tags;
+        try {
+            logger.info(`   Running: git tag -l "${tagPattern}" --sort=-version:refname`);
+            const { stdout } = await runSecure('git', [
+                'tag',
+                '-l',
+                tagPattern,
+                '--sort=-version:refname'
+            ]);
+            tags = stdout.trim().split('\n').filter((tag)=>tag.length > 0);
+            logger.info(`   ✅ Found ${tags.length} tags matching pattern "${tagPattern}"`);
+            if (tags.length > 0) {
+                logger.info(`   📋 Tags (newest first): ${tags.slice(0, 15).join(', ')}${tags.length > 15 ? ` ... (${tags.length - 15} more)` : ''}`);
+            }
+        } catch (sortError) {
+            // Fallback for older git versions that don't support --sort
+            logger.info(`   ⚠️  Git tag --sort failed: ${sortError.message}`);
+            logger.info(`   Falling back to manual sorting...`);
+            const { stdout } = await runSecure('git', [
+                'tag',
+                '-l',
+                tagPattern
+            ]);
+            tags = stdout.trim().split('\n').filter((tag)=>tag.length > 0);
+            logger.info(`   Found ${tags.length} tags (unsorted) matching pattern "${tagPattern}"`);
+            // Manual semantic version sorting
+            tags.sort((a, b)=>{
+                const aMatch = a.match(/v?(\d+\.\d+\.\d+.*?)$/);
+                const bMatch = b.match(/v?(\d+\.\d+\.\d+.*?)$/);
+                if (!aMatch || !bMatch) return 0;
+                const aSemver = semver.parse(aMatch[1]);
+                const bSemver = semver.parse(bMatch[1]);
+                if (!aSemver || !bSemver) return 0;
+                return semver.rcompare(aSemver, bSemver);
+            });
+            logger.info(`   ✅ Sorted ${tags.length} tags manually`);
+        }
+        if (tags.length === 0) {
+            logger.warn('');
+            logger.warn(`❌ NO TAGS FOUND matching pattern "${tagPattern}"`);
+            logger.warn(`   To verify, run: git tag -l '${tagPattern}'`);
+            logger.warn('');
+            return null;
+        }
+        logger.info(`   🔬 Processing ${tags.length} tags to find the highest version < ${currentVersion}...`);
+        // Find the highest version that is less than the current version
+        let previousTag = null;
+        let previousVersion = null;
+        let validTags = 0;
+        let skippedTags = 0;
+        for (const tag of tags){
+            // Extract version from tag - handle "v1.2.13", "1.2.13", and "working/v1.2.13"
+            const versionMatch = tag.match(/v?(\d+\.\d+\.\d+.*?)$/);
+            if (!versionMatch) {
+                logger.debug(`   ⏭️  Skipping tag "${tag}" (doesn't match version pattern)`);
+                continue;
+            }
+            const versionString = versionMatch[1];
+            const tagSemver = semver.parse(versionString);
+            if (tagSemver) {
+                validTags++;
+                // Check if this tag version is less than current version
+                if (semver.lt(tagSemver, currentSemver)) {
+                    // If we don't have a previous version yet, or this one is higher than our current previous
+                    if (!previousVersion || semver.gt(tagSemver, previousVersion)) {
+                        previousVersion = tagSemver;
+                        previousTag = tag; // Keep the original tag format
+                        logger.info(`      ✅ New best candidate: ${tag} (${versionString} < ${currentVersion})`);
+                    } else {
+                        logger.debug(`      ⏭️  ${tag} (${versionString}) is < current but not better than ${previousTag}`);
+                    }
+                } else {
+                    skippedTags++;
+                    logger.debug(`      ⏭️  ${tag} (${versionString}) >= current (${currentVersion}), skipping`);
+                }
+            }
+        }
+        logger.info('');
+        logger.info(`   📊 Tag analysis results:`);
+        logger.info(`      - Total tags examined: ${tags.length}`);
+        logger.info(`      - Valid semver tags: ${validTags}`);
+        logger.info(`      - Tags >= current version (skipped): ${skippedTags}`);
+        logger.info(`      - Best match: ${previousTag || 'none'}`);
+        logger.info('');
+        if (previousTag) {
+            logger.info(`✅ SUCCESS: Found previous tag: ${previousTag}`);
+            logger.info(`   Version comparison: ${previousVersion === null || previousVersion === void 0 ? void 0 : previousVersion.version} < ${currentVersion}`);
+            logger.info('');
+            return previousTag;
+        }
+        logger.warn(`❌ FAILED: No previous tag found for version ${currentVersion}`);
+        logger.warn(`   Pattern searched: "${tagPattern}"`);
+        logger.warn(`   Reason: All ${validTags} valid tags were >= ${currentVersion}`);
+        logger.warn('');
+        return null;
+    } catch (error) {
+        logger.debug(`Error finding previous release tag: ${error.message}`);
+        return null;
+    }
+};
+/**
+ * Gets the current version from package.json
+ *
+ * @returns The current version string or null if not found
+ */ const getCurrentVersion = async ()=>{
+    const logger = getLogger();
+    try {
+        // First try to get from committed version in HEAD
+        const { stdout } = await runSecure('git', [
+            'show',
+            'HEAD:package.json'
+        ]);
+        const packageJson = safeJsonParse(stdout, 'package.json');
+        const validated = validatePackageJson(packageJson, 'package.json');
+        if (validated.version) {
+            logger.debug(`Current version from HEAD:package.json: ${validated.version}`);
+            return validated.version;
+        }
+        return null;
+    } catch (error) {
+        logger.debug(`Could not read version from HEAD:package.json: ${error.message}`);
+        // Fallback to reading from working directory
+        try {
+            const packageJsonPath = path.join(process.cwd(), 'package.json');
+            const content = await fs.readFile(packageJsonPath, 'utf-8');
+            const packageJson = safeJsonParse(content, 'package.json');
+            const validated = validatePackageJson(packageJson, 'package.json');
+            if (validated.version) {
+                logger.debug(`Current version from working directory package.json: ${validated.version}`);
+                return validated.version;
+            }
+            return null;
+        } catch (fallbackError) {
+            logger.debug(`Error reading current version from filesystem: ${fallbackError.message}`);
+            return null;
+        }
+    }
+};
+/**
+ * Gets a reliable default for the --from parameter by trying multiple fallbacks
+ *
+ * Tries in order:
+ * 1. Previous working branch tag (if on working branch)
+ * 2. Previous release tag (if current version can be determined)
+ * 3. main (local main branch - typical release comparison base)
+ * 4. master (local master branch - legacy default)
+ * 5. origin/main (remote main branch fallback)
+ * 6. origin/master (remote master branch fallback)
+ *
+ * @param forceMainBranch If true, skip tag detection and use main branch
+ * @param currentBranch Current branch name for branch-aware tag detection
+ * @returns A valid git reference to use as the default from parameter
+ * @throws Error if no valid reference can be found
+ */ const getDefaultFromRef = async (forceMainBranch = false, currentBranch)=>{
+    const logger = getLogger();
+    logger.info('');
+    logger.info('═══════════════════════════════════════════════════════════');
+    logger.info('🔍 DETECTING DEFAULT --from REFERENCE FOR RELEASE NOTES');
+    logger.info('═══════════════════════════════════════════════════════════');
+    logger.info(`📋 Input parameters:`);
+    logger.info(`   - forceMainBranch: ${forceMainBranch}`);
+    logger.info(`   - currentBranch: "${currentBranch}"`);
+    logger.info('');
+    // If forced to use main branch, skip tag detection
+    if (forceMainBranch) {
+        logger.info('⚡ Forced to use main branch, skipping tag detection');
+    } else {
+        // If on working branch, look for working branch tags first
+        logger.info(`🎯 Branch check: currentBranch="${currentBranch}", isWorking=${currentBranch === 'working'}`);
+        if (currentBranch && currentBranch === 'working') {
+            logger.info('');
+            logger.info('📍 DETECTED WORKING BRANCH - Searching for working branch tags...');
+            logger.info('───────────────────────────────────────────────────────────');
+            try {
+                const currentVersion = await getCurrentVersion();
+                logger.info(`📦 Current version from package.json: ${currentVersion}`);
+                if (currentVersion) {
+                    logger.info(`🔍 Searching for tags matching pattern: "working/v*"`);
+                    logger.info(`   (Looking for tags < ${currentVersion})`);
+                    logger.info('');
+                    const previousTag = await findPreviousReleaseTag(currentVersion, 'working/v*');
+                    logger.info(`🎯 findPreviousReleaseTag result: ${previousTag || 'null (no tag found)'}`);
+                    if (previousTag) {
+                        logger.info(`🔬 Validating tag reference: "${previousTag}"`);
+                        const isValid = await isValidGitRef(previousTag);
+                        logger.info(`   Tag is valid git ref: ${isValid}`);
+                        if (isValid) {
+                            logger.info('');
+                            logger.info(`✅ SUCCESS: Using previous working branch tag '${previousTag}'`);
+                            logger.info(`   This shows commits added since the last release`);
+                            logger.info('═══════════════════════════════════════════════════════════');
+                            logger.info('');
+                            return previousTag;
+                        } else {
+                            logger.warn('');
+                            logger.warn(`⚠️  VALIDATION FAILED: Tag "${previousTag}" exists but is not a valid git reference`);
+                            logger.warn(`   This should not happen - the tag might be corrupted`);
+                        }
+                    } else {
+                        logger.warn('');
+                        logger.warn('❌ NO WORKING BRANCH TAG FOUND matching pattern "working/v*"');
+                        logger.warn(`   Current version: ${currentVersion}`);
+                        logger.warn('   💡 To create working branch tags for past releases, run:');
+                        logger.warn('      kodrdriv development --create-retroactive-tags');
+                        logger.warn('');
+                        logger.warn('   Falling back to regular tag search...');
+                    }
+                } else {
+                    logger.warn('');
+                    logger.warn('❌ CANNOT READ VERSION from package.json');
+                    logger.warn('   Cannot search for working branch tags without current version');
+                }
+            } catch (error) {
+                logger.warn('');
+                logger.warn(`❌ ERROR while searching for working branch tag: ${error.message}`);
+                logger.debug(`Full error stack: ${error.stack}`);
+                logger.warn('   Falling back to regular tag search...');
+            }
+            logger.info('───────────────────────────────────────────────────────────');
+            logger.info('');
+        } else {
+            logger.info(`ℹ️  Not on "working" branch - skipping working tag search`);
+            logger.info(`   (Only search for working/v* tags when on working branch)`);
+            logger.info('');
+        }
+        // First, try to find the previous release tag
+        try {
+            const currentVersion = await getCurrentVersion();
+            if (currentVersion) {
+                const previousTag = await findPreviousReleaseTag(currentVersion);
+                if (previousTag && await isValidGitRef(previousTag)) {
+                    logger.info(`Using previous release tag '${previousTag}' as default --from reference`);
+                    return previousTag;
+                }
+            }
+        } catch (error) {
+            logger.debug(`Could not determine previous release tag: ${error.message}`);
+        }
+    }
+    // Fallback to branch-based references
+    const candidates = [
+        'main',
+        'master',
+        'origin/main',
+        'origin/master'
+    ];
+    for (const candidate of candidates){
+        logger.debug(`Testing git reference candidate: ${candidate}`);
+        if (await isValidGitRef(candidate)) {
+            if (forceMainBranch) {
+                logger.info(`Using '${candidate}' as forced main branch reference`);
+            } else {
+                logger.info(`Using '${candidate}' as fallback --from reference (no previous release tag found)`);
+            }
+            return candidate;
+        }
+    }
+    // If we get here, something is seriously wrong with the git repository
+    throw new Error('Could not find a valid default git reference for --from parameter. ' + 'Please specify --from explicitly or check your git repository configuration. ' + `Tried: ${forceMainBranch ? 'main branch only' : 'previous release tag'}, ${candidates.join(', ')}`);
+};
+/**
+ * Gets the default branch name from the remote repository
+ */ const getRemoteDefaultBranch = async (cwd)=>{
+    const logger = getLogger();
+    try {
+        // Try to get the symbolic reference for origin/HEAD
+        const { stdout } = await run('git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null || echo ""', {
+            cwd,
+            suppressErrorLogging: true
+        });
+        if (stdout.trim()) {
+            // Extract branch name from refs/remotes/origin/branch-name
+            const match = stdout.trim().match(/refs\/remotes\/origin\/(.+)$/);
+            if (match) {
+                const branchName = match[1];
+                logger.debug(`Remote default branch is: ${branchName}`);
+                return branchName;
+            }
+        }
+        // Fallback: try to get it from ls-remote
+        const { stdout: lsRemoteOutput } = await run('git ls-remote --symref origin HEAD', {
+            cwd,
+            suppressErrorLogging: true
+        });
+        const symrefMatch = lsRemoteOutput.match(/ref: refs\/heads\/(.+)\s+HEAD/);
+        if (symrefMatch) {
+            const branchName = symrefMatch[1];
+            logger.debug(`Remote default branch from ls-remote: ${branchName}`);
+            return branchName;
+        }
+        logger.debug('Could not determine remote default branch');
+        return null;
+    } catch (error) {
+        logger.debug(`Failed to get remote default branch: ${error}`);
+        return null;
+    }
+};
+/**
+ * Checks if a directory is a git repository
+ * @param cwd Directory to check
+ * @returns true if directory is a git repository
+ */ const isGitRepository = async (cwd)=>{
+    try {
+        await run('git rev-parse --is-inside-work-tree', {
+            cwd,
+            suppressErrorLogging: true
+        });
+        return true;
+    } catch  {
+        return false;
+    }
+};
+/**
+ * Checks if a local branch exists
+ */ const localBranchExists = async (branchName)=>{
+    const logger = getLogger();
+    const result = await isValidGitRefSilent(`refs/heads/${branchName}`);
+    if (result) {
+        logger.debug(`Local branch '${branchName}' exists`);
+    } else {
+        logger.debug(`Local branch '${branchName}' does not exist`);
+    }
+    return result;
+};
+/**
+ * Checks if a remote branch exists
+ */ const remoteBranchExists = async (branchName, remote = 'origin')=>{
+    const logger = getLogger();
+    const result = await isValidGitRefSilent(`refs/remotes/${remote}/${branchName}`);
+    if (result) {
+        logger.debug(`Remote branch '${remote}/${branchName}' exists`);
+    } else {
+        logger.debug(`Remote branch '${remote}/${branchName}' does not exist`);
+    }
+    return result;
+};
+/**
+ * Gets the commit SHA for a given branch (local or remote)
+ */ const getBranchCommitSha = async (branchRef)=>{
+    // Validate the ref first to prevent injection
+    if (!validateGitRef(branchRef)) {
+        throw new Error(`Invalid git reference: ${branchRef}`);
+    }
+    const { stdout } = await runSecure('git', [
+        'rev-parse',
+        branchRef
+    ]);
+    return stdout.trim();
+};
+/**
+ * Checks if a local branch is in sync with its remote counterpart
+ */ const isBranchInSyncWithRemote = async (branchName, remote = 'origin')=>{
+    const logger = getLogger();
+    try {
+        // Validate inputs first to prevent injection
+        if (!validateGitRef(branchName)) {
+            throw new Error(`Invalid branch name: ${branchName}`);
+        }
+        if (!validateGitRef(remote)) {
+            throw new Error(`Invalid remote name: ${remote}`);
+        }
+        // First, fetch latest remote refs without affecting working directory
+        await runSecure('git', [
+            'fetch',
+            remote,
+            '--quiet'
+        ]);
+        const localExists = await localBranchExists(branchName);
+        const remoteExists = await remoteBranchExists(branchName, remote);
+        if (!localExists) {
+            return {
+                inSync: false,
+                localExists: false,
+                remoteExists,
+                error: `Local branch '${branchName}' does not exist`
+            };
+        }
+        if (!remoteExists) {
+            return {
+                inSync: false,
+                localExists: true,
+                remoteExists: false,
+                error: `Remote branch '${remote}/${branchName}' does not exist`
+            };
+        }
+        // Both branches exist, compare their SHAs
+        const localSha = await getBranchCommitSha(`refs/heads/${branchName}`);
+        const remoteSha = await getBranchCommitSha(`refs/remotes/${remote}/${branchName}`);
+        const inSync = localSha === remoteSha;
+        logger.debug(`Branch sync check for '${branchName}': local=${localSha.substring(0, 8)}, remote=${remoteSha.substring(0, 8)}, inSync=${inSync}`);
+        return {
+            inSync,
+            localSha,
+            remoteSha,
+            localExists: true,
+            remoteExists: true
+        };
+    } catch (error) {
+        logger.debug(`Failed to check branch sync for '${branchName}': ${error.message}`);
+        return {
+            inSync: false,
+            localExists: false,
+            remoteExists: false,
+            error: `Failed to check branch sync: ${error.message}`
+        };
+    }
+};
+/**
+ * Attempts to safely sync a local branch with its remote counterpart
+ * Returns true if successful, false if conflicts exist that require manual resolution
+ */ const safeSyncBranchWithRemote = async (branchName, remote = 'origin')=>{
+    const logger = getLogger();
+    // Validate the remote parameter to prevent command injection
+    if (!isValidGitRemoteName(remote)) {
+        return {
+            success: false,
+            error: `Invalid remote name: '${remote}'`
+        };
+    }
+    try {
+        // Validate inputs first to prevent injection
+        if (!validateGitRef(branchName)) {
+            throw new Error(`Invalid branch name: ${branchName}`);
+        }
+        if (!validateGitRef(remote)) {
+            throw new Error(`Invalid remote name: ${remote}`);
+        }
+        // Explicitly disallow remotes that look like command-line options (e.g. "--upload-pack")
+        if (remote.startsWith('-')) {
+            throw new Error(`Disallowed remote name (cannot start with '-'): ${remote}`);
+        }
+        // Check current branch to restore later if needed
+        const { stdout: currentBranch } = await runSecure('git', [
+            'branch',
+            '--show-current'
+        ]);
+        const originalBranch = currentBranch.trim();
+        // Fetch latest remote refs
+        await runSecure('git', [
+            'fetch',
+            remote,
+            '--quiet'
+        ]);
+        // Check if local branch exists
+        const localExists = await localBranchExists(branchName);
+        const remoteExists = await remoteBranchExists(branchName, remote);
+        if (!remoteExists) {
+            return {
+                success: false,
+                error: `Remote branch '${remote}/${branchName}' does not exist`
+            };
+        }
+        if (!localExists) {
+            // Create local branch tracking the remote
+            await runSecure('git', [
+                'branch',
+                branchName,
+                `${remote}/${branchName}`
+            ]);
+            logger.debug(`Created local branch '${branchName}' tracking '${remote}/${branchName}'`);
+            return {
+                success: true
+            };
+        }
+        // Check if we need to switch to the target branch
+        const needToSwitch = originalBranch !== branchName;
+        if (needToSwitch) {
+            // Check for uncommitted changes before switching
+            const { stdout: statusOutput } = await runSecure('git', [
+                'status',
+                '--porcelain'
+            ]);
+            if (statusOutput.trim()) {
+                return {
+                    success: false,
+                    error: `Cannot switch to branch '${branchName}' because you have uncommitted changes. Please commit or stash your changes first.`
+                };
+            }
+            // Switch to target branch
+            await runSecure('git', [
+                'checkout',
+                branchName
+            ]);
+        }
+        try {
+            // Try to pull with fast-forward only
+            await runSecure('git', [
+                'pull',
+                remote,
+                branchName,
+                '--ff-only'
+            ]);
+            logger.debug(`Successfully synced '${branchName}' with '${remote}/${branchName}'`);
+            // Switch back to original branch if we switched
+            if (needToSwitch && originalBranch) {
+                await runSecure('git', [
+                    'checkout',
+                    originalBranch
+                ]);
+            }
+            return {
+                success: true
+            };
+        } catch (pullError) {
+            // Switch back to original branch if we switched
+            if (needToSwitch && originalBranch) {
+                try {
+                    await runSecure('git', [
+                        'checkout',
+                        originalBranch
+                    ]);
+                } catch (checkoutError) {
+                    logger.warn(`Failed to switch back to original branch '${originalBranch}': ${checkoutError}`);
+                }
+            }
+            // Check if this is a merge conflict or diverged branches
+            if (pullError.message.includes('diverged') || pullError.message.includes('non-fast-forward') || pullError.message.includes('conflict') || pullError.message.includes('CONFLICT')) {
+                return {
+                    success: false,
+                    conflictResolutionRequired: true,
+                    error: `Branch '${branchName}' has diverged from '${remote}/${branchName}' and requires manual conflict resolution`
+                };
+            }
+            return {
+                success: false,
+                error: `Failed to sync branch '${branchName}': ${pullError.message}`
+            };
+        }
+    } catch (error) {
+        return {
+            success: false,
+            error: `Failed to sync branch '${branchName}': ${error.message}`
+        };
+    }
+};
+/**
+ * Gets the current branch name
+ */ const getCurrentBranch = async ()=>{
+    const { stdout } = await runSecure('git', [
+        'branch',
+        '--show-current'
+    ]);
+    return stdout.trim();
+};
+/**
+ * Gets git status summary including unstaged files, uncommitted changes, and unpushed commits
+ */ const getGitStatusSummary = async (workingDir)=>{
+    const logger = getLogger();
+    try {
+        const originalCwd = process.cwd();
+        if (workingDir) {
+            process.chdir(workingDir);
+        }
+        try {
+            // Get current branch
+            const branch = await getCurrentBranch();
+            // Get git status for unstaged and uncommitted changes
+            const { stdout: statusOutput } = await runSecure('git', [
+                'status',
+                '--porcelain'
+            ]);
+            const statusLines = statusOutput.trim().split('\n').filter((line)=>line.trim());
+            // Count different types of changes
+            let unstagedCount = 0;
+            let uncommittedCount = 0;
+            for (const line of statusLines){
+                const statusCode = line.substring(0, 2);
+                // For untracked files (??) count as unstaged only once
+                if (statusCode === '??') {
+                    unstagedCount++;
+                    continue;
+                }
+                // Check for unstaged changes (working directory changes)
+                // Second character represents working tree status
+                if (statusCode[1] !== ' ' && statusCode[1] !== '') {
+                    unstagedCount++;
+                }
+                // Check for uncommitted changes (staged changes)
+                // First character represents index status
+                if (statusCode[0] !== ' ' && statusCode[0] !== '') {
+                    uncommittedCount++;
+                }
+            }
+            // Check for unpushed commits by comparing with remote
+            let unpushedCount = 0;
+            let hasUnpushedCommits = false;
+            try {
+                // First fetch to get latest remote refs
+                await runSecure('git', [
+                    'fetch',
+                    'origin',
+                    '--quiet'
+                ]);
+                // Check if remote branch exists
+                const remoteExists = await remoteBranchExists(branch);
+                if (remoteExists) {
+                    // Get count of commits ahead of remote (branch already validated in calling function)
+                    const { stdout: aheadOutput } = await runSecure('git', [
+                        'rev-list',
+                        '--count',
+                        `origin/${branch}..HEAD`
+                    ]);
+                    unpushedCount = parseInt(aheadOutput.trim()) || 0;
+                    hasUnpushedCommits = unpushedCount > 0;
+                }
+            } catch (error) {
+                logger.debug(`Could not check for unpushed commits: ${error}`);
+            // Remote might not exist or other issues - not critical for status
+            }
+            const hasUnstagedFiles = unstagedCount > 0;
+            const hasUncommittedChanges = uncommittedCount > 0;
+            // Build status summary
+            const statusParts = [];
+            if (hasUnstagedFiles) {
+                statusParts.push(`${unstagedCount} unstaged`);
+            }
+            if (hasUncommittedChanges) {
+                statusParts.push(`${uncommittedCount} uncommitted`);
+            }
+            if (hasUnpushedCommits) {
+                statusParts.push(`${unpushedCount} unpushed`);
+            }
+            const status = statusParts.length > 0 ? statusParts.join(', ') : 'clean';
+            return {
+                branch,
+                hasUnstagedFiles,
+                hasUncommittedChanges,
+                hasUnpushedCommits,
+                unstagedCount,
+                uncommittedCount,
+                unpushedCount,
+                status
+            };
+        } finally{
+            if (workingDir) {
+                process.chdir(originalCwd);
+            }
+        }
+    } catch (error) {
+        logger.debug(`Failed to get git status summary: ${error.message}`);
+        return {
+            branch: 'unknown',
+            hasUnstagedFiles: false,
+            hasUncommittedChanges: false,
+            hasUnpushedCommits: false,
+            unstagedCount: 0,
+            uncommittedCount: 0,
+            unpushedCount: 0,
+            status: 'error'
+        };
+    }
+};
+/**
+ * Gets the list of globally linked packages (packages available to be linked to)
+ */ const getGloballyLinkedPackages = async ()=>{
+    const execPromise = util.promisify(exec);
+    try {
+        const { stdout } = await execPromise('npm ls --link -g --json');
+        const result = safeJsonParse(stdout, 'npm ls global output');
+        if (result.dependencies && typeof result.dependencies === 'object') {
+            return new Set(Object.keys(result.dependencies));
+        }
+        return new Set();
+    } catch (error) {
+        // Try to parse from error stdout if available
+        if (error.stdout) {
+            try {
+                const result = safeJsonParse(error.stdout, 'npm ls global error output');
+                if (result.dependencies && typeof result.dependencies === 'object') {
+                    return new Set(Object.keys(result.dependencies));
+                }
+            } catch  {
+            // If JSON parsing fails, return empty set
+            }
+        }
+        return new Set();
+    }
+};
+/**
+ * Gets the list of packages that this package is actively linking to (consuming linked packages)
+ */ const getLinkedDependencies = async (packageDir)=>{
+    const execPromise = util.promisify(exec);
+    try {
+        const { stdout } = await execPromise('npm ls --link --json', {
+            cwd: packageDir
+        });
+        const result = safeJsonParse(stdout, 'npm ls local output');
+        if (result.dependencies && typeof result.dependencies === 'object') {
+            return new Set(Object.keys(result.dependencies));
+        }
+        return new Set();
+    } catch (error) {
+        // npm ls --link often exits with non-zero code but still provides valid JSON in stdout
+        if (error.stdout) {
+            try {
+                const result = safeJsonParse(error.stdout, 'npm ls local error output');
+                if (result.dependencies && typeof result.dependencies === 'object') {
+                    return new Set(Object.keys(result.dependencies));
+                }
+            } catch  {
+            // If JSON parsing fails, return empty set
+            }
+        }
+        return new Set();
+    }
+};
+/**
+ * Checks for actual semantic version compatibility issues between linked packages and their consumers
+ * Returns a set of dependency names that have real compatibility problems
+ *
+ * This function ignores npm's strict prerelease handling and focuses on actual compatibility:
+ * - "^4.4" is compatible with "4.4.53-dev.0" (prerelease of compatible minor version)
+ * - "^4.4" is incompatible with "4.5.3" (different minor version)
+ */ const getLinkCompatibilityProblems = async (packageDir, allPackagesInfo)=>{
+    try {
+        // Read the consumer package.json
+        const packageJsonPath = path.join(packageDir, 'package.json');
+        const packageJsonContent = await fs.readFile(packageJsonPath, 'utf-8');
+        const parsed = safeJsonParse(packageJsonContent, packageJsonPath);
+        const packageJson = validatePackageJson(parsed, packageJsonPath);
+        const problemDependencies = new Set();
+        // Get linked dependencies
+        const linkedDeps = await getLinkedDependencies(packageDir);
+        // Check each dependency type
+        const dependencyTypes = [
+            'dependencies',
+            'devDependencies',
+            'peerDependencies',
+            'optionalDependencies'
+        ];
+        for (const depType of dependencyTypes){
+            const deps = packageJson[depType];
+            if (!deps || typeof deps !== 'object') continue;
+            for (const [depName, versionRange] of Object.entries(deps)){
+                // Only check dependencies that are currently linked
+                if (!linkedDeps.has(depName)) continue;
+                // Skip if version range is not a string or is invalid
+                if (typeof versionRange !== 'string') continue;
+                try {
+                    let linkedVersion;
+                    // If we have package info provided, use it
+                    if (allPackagesInfo) {
+                        const packageInfo = allPackagesInfo.get(depName);
+                        if (packageInfo) {
+                            linkedVersion = packageInfo.version;
+                        }
+                    }
+                    // If we don't have version from package info, try to read it from the linked package
+                    if (!linkedVersion) {
+                        try {
+                            // Get the linked package path and read its version
+                            const nodeModulesPath = path.join(packageDir, 'node_modules', depName, 'package.json');
+                            const linkedPackageJson = await fs.readFile(nodeModulesPath, 'utf-8');
+                            const linkedParsed = safeJsonParse(linkedPackageJson, nodeModulesPath);
+                            const linkedValidated = validatePackageJson(linkedParsed, nodeModulesPath);
+                            linkedVersion = linkedValidated.version;
+                        } catch  {
+                            continue;
+                        }
+                    }
+                    if (!linkedVersion) continue;
+                    // Check compatibility with custom logic for prerelease versions
+                    if (!isVersionCompatibleWithRange(linkedVersion, versionRange)) {
+                        problemDependencies.add(depName);
+                    }
+                } catch  {
+                    continue;
+                }
+            }
+        }
+        return problemDependencies;
+    } catch  {
+        // If we can't read the package.json or process it, return empty set
+        return new Set();
+    }
+};
+/**
+ * Custom semver compatibility check that handles prerelease versions more intelligently
+ * than npm's strict checking, with stricter caret range handling
+ *
+ * Examples:
+ * - isVersionCompatibleWithRange("4.4.53-dev.0", "^4.4") => true
+ * - isVersionCompatibleWithRange("4.5.3", "^4.4") => false
+ * - isVersionCompatibleWithRange("4.4.1", "^4.4") => true
+ */ const isVersionCompatibleWithRange = (version, range)=>{
+    try {
+        const parsedVersion = semver.parse(version);
+        if (!parsedVersion) return false;
+        // Parse the range to understand what we're comparing against
+        const rangeObj = semver.validRange(range);
+        if (!rangeObj) return false;
+        // For caret ranges like "^4.4", we want more strict checking than semver's default
+        if (range.startsWith('^')) {
+            const rangeVersion = range.substring(1); // Remove the ^
+            // Try to parse as a complete version first
+            let parsedRange = semver.parse(rangeVersion);
+            // If that fails, try to coerce it (handles cases like "4.4" -> "4.4.0")
+            if (!parsedRange) {
+                const coercedRange = semver.coerce(rangeVersion);
+                if (coercedRange) {
+                    parsedRange = coercedRange;
+                } else {
+                    return false;
+                }
+            }
+            // For prerelease versions, check if the base version (without prerelease)
+            // matches the major.minor from the range
+            if (parsedVersion.prerelease.length > 0) {
+                return parsedVersion.major === parsedRange.major && parsedVersion.minor === parsedRange.minor;
+            }
+            // For regular versions with caret ranges, be strict about minor version
+            // ^4.4 should only accept 4.4.x, not 4.5.x
+            return parsedVersion.major === parsedRange.major && parsedVersion.minor === parsedRange.minor;
+        }
+        // For other range types (exact, tilde, etc.), use standard semver checking
+        if (parsedVersion.prerelease.length > 0) {
+            const baseVersion = `${parsedVersion.major}.${parsedVersion.minor}.${parsedVersion.patch}`;
+            return semver.satisfies(baseVersion, range);
+        }
+        return semver.satisfies(version, range);
+    } catch  {
+        // If semver parsing fails, assume incompatible
+        return false;
+    }
+};
+/**
+ * Checks for npm link problems (version mismatches) in a package directory
+ * Returns a set of dependency names that have link problems
+ *
+ * @deprecated Use getLinkCompatibilityProblems instead for better prerelease version handling
+ */ const getLinkProblems = async (packageDir)=>{
+    const execPromise = util.promisify(exec);
+    try {
+        const { stdout } = await execPromise('npm ls --link --json', {
+            cwd: packageDir
+        });
+        const result = safeJsonParse(stdout, 'npm ls troubleshoot output');
+        const problemDependencies = new Set();
+        // Check if there are any problems reported
+        if (result.problems && Array.isArray(result.problems)) {
+            // Parse problems array to extract dependency names
+            for (const problem of result.problems){
+                if (typeof problem === 'string' && problem.includes('invalid:')) {
+                    // Extract package name from problem string like "invalid: @fjell/eslint-config@1.1.20-dev.0 ..."
+                    // Handle both scoped (@scope/name) and unscoped (name) packages
+                    const match = problem.match(/invalid:\s+(@[^/]+\/[^@\s]+|[^@\s]+)@/);
+                    if (match) {
+                        problemDependencies.add(match[1]);
+                    }
+                }
+            }
+        }
+        // Also check individual dependencies for problems
+        if (result.dependencies && typeof result.dependencies === 'object') {
+            for (const [depName, depInfo] of Object.entries(result.dependencies)){
+                if (depInfo && typeof depInfo === 'object') {
+                    const dep = depInfo;
+                    // Check if this dependency has problems or is marked as invalid
+                    if (dep.problems && Array.isArray(dep.problems) && dep.problems.length > 0 || dep.invalid) {
+                        problemDependencies.add(depName);
+                    }
+                }
+            }
+        }
+        return problemDependencies;
+    } catch (error) {
+        // npm ls --link often exits with non-zero code when there are problems
+        // but still provides valid JSON in stdout
+        if (error.stdout) {
+            try {
+                const result = safeJsonParse(error.stdout, 'npm ls troubleshoot error output');
+                const problemDependencies = new Set();
+                // Check if there are any problems reported
+                if (result.problems && Array.isArray(result.problems)) {
+                    for (const problem of result.problems){
+                        if (typeof problem === 'string' && problem.includes('invalid:')) {
+                            const match = problem.match(/invalid:\s+(@[^/]+\/[^@\s]+|[^@\s]+)@/);
+                            if (match) {
+                                problemDependencies.add(match[1]);
+                            }
+                        }
+                    }
+                }
+                // Also check individual dependencies for problems
+                if (result.dependencies && typeof result.dependencies === 'object') {
+                    for (const [depName, depInfo] of Object.entries(result.dependencies)){
+                        if (depInfo && typeof depInfo === 'object') {
+                            const dep = depInfo;
+                            if (dep.problems && Array.isArray(dep.problems) && dep.problems.length > 0 || dep.invalid) {
+                                problemDependencies.add(depName);
+                            }
+                        }
+                    }
+                }
+                return problemDependencies;
+            } catch  {
+                // If JSON parsing fails, return empty set
+                return new Set();
+            }
+        }
+        return new Set();
+    }
+};
+/**
+ * Checks if a package directory is npm linked (has a global symlink)
+ */ const isNpmLinked = async (packageDir)=>{
+    const logger = getLogger();
+    try {
+        // Read package.json to get the package name
+        const packageJsonPath = path.join(packageDir, 'package.json');
+        try {
+            await fs.access(packageJsonPath);
+        } catch  {
+            // No package.json found
+            return false;
+        }
+        const packageJsonContent = await fs.readFile(packageJsonPath, 'utf-8');
+        const packageJson = safeJsonParse(packageJsonContent, packageJsonPath);
+        const packageName = packageJson.name;
+        if (!packageName) {
+            return false;
+        }
+        // Check if the package is globally linked by running npm ls -g --depth=0
+        try {
+            const { stdout } = await runSecure('npm', [
+                'ls',
+                '-g',
+                '--depth=0',
+                '--json'
+            ]);
+            const globalPackages = safeJsonParse(stdout, 'npm ls global depth check output');
+            // Check if our package is in the global dependencies
+            if (globalPackages.dependencies && globalPackages.dependencies[packageName]) {
+                // Verify the symlink actually points to our directory
+                const globalPath = globalPackages.dependencies[packageName].resolved;
+                if (globalPath && globalPath.startsWith('file:')) {
+                    const linkedPath = globalPath.replace('file:', '');
+                    const realPackageDir = await fs.realpath(packageDir);
+                    const realLinkedPath = await fs.realpath(linkedPath);
+                    return realPackageDir === realLinkedPath;
+                }
+            }
+        } catch (error) {
+            // If npm ls fails, try alternative approach
+            logger.debug(`npm ls failed for ${packageName}, trying alternative check: ${error}`);
+            // Alternative: check if there's a symlink in npm's global node_modules
+            try {
+                const { stdout: npmPrefix } = await run('npm prefix -g');
+                const globalNodeModules = path.join(npmPrefix.trim(), 'node_modules', packageName);
+                const stat = await fs.lstat(globalNodeModules);
+                if (stat.isSymbolicLink()) {
+                    const realGlobalPath = await fs.realpath(globalNodeModules);
+                    const realPackageDir = await fs.realpath(packageDir);
+                    return realGlobalPath === realPackageDir;
+                }
+            } catch  {
+                // If all else fails, assume not linked
+                return false;
+            }
+        }
+        return false;
+    } catch (error) {
+        logger.debug(`Error checking npm link status for ${packageDir}: ${error}`);
+        return false;
+    }
+};
+
+export { ConsoleLogger, escapeShellArg, findPreviousReleaseTag, getBranchCommitSha, getCurrentBranch, getCurrentVersion, getDefaultFromRef, getGitStatusSummary, getGloballyLinkedPackages, getLinkCompatibilityProblems, getLinkProblems, getLinkedDependencies, getLogger, getRemoteDefaultBranch, isBranchInSyncWithRemote, isGitRepository, isNpmLinked, isValidGitRef, localBranchExists, remoteBranchExists, run, runSecure, runSecureWithDryRunSupport, runSecureWithInheritedStdio, runWithDryRunSupport, runWithInheritedStdio, safeJsonParse, safeSyncBranchWithRemote, setLogger, validateFilePath, validateGitRef, validateHasProperty, validatePackageJson, validateString };
 //# sourceMappingURL=index.js.map