@eldrforge/kodrdriv 1.2.19 → 1.2.20

package/dist/util/git.js

@@ -1,836 +0,0 @@
-import { getLogger } from '../logging.js';
-import { runSecure, validateGitRef } from './child.js';
-import fs__default from 'fs/promises';
-import path__default from 'path';
-import { exec } from 'child_process';
-import util from 'util';
-import * as semver from 'semver';
-import { safeJsonParse, validatePackageJson } from './validation.js';
-
-/**
- * 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'
-        });
-        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__default.join(process.cwd(), 'package.json');
-            const content = await fs__default.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(', ')}`);
-};
-/**
- * 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();
-    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}`);
-        }
-        // 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__default.join(packageDir, 'package.json');
-        const packageJsonContent = await fs__default.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__default.join(packageDir, 'node_modules', depName, 'package.json');
-                            const linkedPackageJson = await fs__default.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;
-    }
-};
-
-export { findPreviousReleaseTag, getBranchCommitSha, getCurrentBranch, getCurrentVersion, getDefaultFromRef, getGitStatusSummary, getGloballyLinkedPackages, getLinkCompatibilityProblems, getLinkedDependencies, isBranchInSyncWithRemote, isValidGitRef, localBranchExists, remoteBranchExists, safeSyncBranchWithRemote };
-//# sourceMappingURL=git.js.map