@eldrforge/kodrdriv 0.1.0 → 1.2.0

package/dist/util/git.js

@@ -0,0 +1,587 @@
+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;
+    }
+};
+/**
+ * Gets a reliable default for the --from parameter by trying multiple fallbacks
+ *
+ * Tries in order:
+ * 1. main (local main branch - typical release comparison base)
+ * 2. master (local master branch - legacy default)
+ * 3. origin/main (remote main branch fallback)
+ * 4. origin/master (remote master branch fallback)
+ *
+ * @returns A valid git reference to use as the default from parameter
+ * @throws Error if no valid reference can be found
+ */ const getDefaultFromRef = async ()=>{
+    const logger = getLogger();
+    const candidates = [
+        'main',
+        'master',
+        'origin/main',
+        'origin/master'
+    ];
+    for (const candidate of candidates){
+        logger.debug(`Testing git reference candidate: ${candidate}`);
+        if (await isValidGitRef(candidate)) {
+            logger.info(`Using '${candidate}' as default --from reference`);
+            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: ${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 { getBranchCommitSha, getCurrentBranch, getDefaultFromRef, getGitStatusSummary, getGloballyLinkedPackages, getLinkCompatibilityProblems, getLinkedDependencies, isBranchInSyncWithRemote, isValidGitRef, localBranchExists, remoteBranchExists, safeSyncBranchWithRemote };
+//# sourceMappingURL=git.js.map