@eldrforge/kodrdriv 1.2.23 → 1.2.24

package/dist/commands/publish.js

@@ -1,7 +1,7 @@
-import path from 'path';
-import { execute as execute$1 } from './commit.js';
+import path__default from 'path';
+import { execute as execute$2 } from './commit.js';
 import { hasStagedChanges } from '../content/diff.js';
-import { execute as execute$2 } from './release.js';
+import { execute as execute$1 } from './release.js';
 import { getDryRunLogger, getLogger } from '../logging.js';
 import { run, localBranchExists, runSecure, runWithDryRunSupport, safeJsonParse, validatePackageJson, validateGitRef, safeSyncBranchWithRemote, isBranchInSyncWithRemote } from '@eldrforge/git-tools';
 import * as GitHub from '@eldrforge/github-tools';
@@ -9,10 +9,11 @@ import { create } from '../util/storage.js';
 import { calculateBranchDependentVersion, calculateTargetVersion, checkIfTagExists, confirmVersionInteractively, getOutputPath } from '../util/general.js';
 import { DEFAULT_OUTPUT_DIRECTORY, KODRDRIV_DEFAULTS } from '../constants.js';
 import fs from 'fs/promises';
+import { runGitWithLock } from '../util/gitMutex.js';
 
 const scanNpmrcForEnvVars = async (storage)=>{
     const logger = getLogger();
-    const npmrcPath = path.join(process.cwd(), '.npmrc');
+    const npmrcPath = path__default.join(process.cwd(), '.npmrc');
     const envVars = [];
     if (await storage.exists(npmrcPath)) {
         try {
@@ -42,7 +43,7 @@ const scanNpmrcForEnvVars = async (storage)=>{
  * and cleans them up if found by removing package-lock.json and regenerating it.
  */ const cleanupNpmLinkReferences = async (isDryRun)=>{
     const logger = getDryRunLogger(isDryRun);
-    const packageLockPath = path.join(process.cwd(), 'package-lock.json');
+    const packageLockPath = path__default.join(process.cwd(), 'package-lock.json');
     try {
         // Check if package-lock.json exists
         try {
@@ -238,7 +239,7 @@ const runPrechecks = async (runConfig, targetBranch)=>{
     }
     // Check if prepublishOnly script exists in package.json
     logger.info('Checking for prepublishOnly script...');
-    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    const packageJsonPath = path__default.join(process.cwd(), 'package.json');
     if (!await storage.exists(packageJsonPath)) {
         if (!isDryRun) {
             throw new Error('package.json not found in current directory.');
@@ -433,7 +434,10 @@ const execute = async (runConfig)=>{
         try {
             const remoteExists = await run(`git ls-remote --exit-code --heads origin ${currentBranch}`).then(()=>true).catch(()=>false);
             if (remoteExists) {
-                await run(`git pull origin ${currentBranch} --no-edit`);
+                // Wrap git pull with lock to prevent concurrent pulls in same repo
+                await runGitWithLock(process.cwd(), async ()=>{
+                    await run(`git pull origin ${currentBranch} --no-edit`);
+                }, `pull ${currentBranch}`);
                 logger.info(`✅ Synced ${currentBranch} with remote`);
             } else {
                 logger.info(`ℹ️ No remote ${currentBranch} branch found, will be created on first push`);
@@ -490,20 +494,23 @@ const execute = async (runConfig)=>{
         if (!targetBranchExists) {
             logger.info(`🌟 Target branch '${targetBranch}' does not exist, creating it from current branch...`);
             try {
-                // Create the target branch from the current HEAD
-                await runSecure('git', [
-                    'branch',
-                    targetBranch,
-                    'HEAD'
-                ]);
-                logger.info(`✅ Created target branch: ${targetBranch}`);
-                // Push the new branch to origin
-                await runSecure('git', [
-                    'push',
-                    'origin',
-                    targetBranch
-                ]);
-                logger.info(`✅ Pushed new target branch to origin: ${targetBranch}`);
+                // Wrap git branch and push operations with lock
+                await runGitWithLock(process.cwd(), async ()=>{
+                    // Create the target branch from the current HEAD
+                    await runSecure('git', [
+                        'branch',
+                        targetBranch,
+                        'HEAD'
+                    ]);
+                    logger.info(`✅ Created target branch: ${targetBranch}`);
+                    // Push the new branch to origin
+                    await runSecure('git', [
+                        'push',
+                        'origin',
+                        targetBranch
+                    ]);
+                    logger.info(`✅ Pushed new target branch to origin: ${targetBranch}`);
+                }, `create and push target branch ${targetBranch}`);
             } catch (error) {
                 throw new Error(`Failed to create target branch '${targetBranch}': ${error.message}`);
             }
@@ -565,14 +572,20 @@ const execute = async (runConfig)=>{
         // Check if package-lock.json exists before trying to stage it
         const packageLockExists = await storage.exists('package-lock.json');
         const filesToStage = packageLockExists ? 'package.json package-lock.json' : 'package.json';
-        await runWithDryRunSupport(`git add ${filesToStage}`, isDryRun);
+        // Wrap git operations with repository lock to prevent .git/index.lock conflicts
+        await runGitWithLock(process.cwd(), async ()=>{
+            await runWithDryRunSupport(`git add ${filesToStage}`, isDryRun);
+        }, 'stage dependency updates');
         logger.verbose('Checking for staged dependency updates...');
         if (isDryRun) {
             logger.verbose('Would create dependency update commit if changes are staged');
         } else {
             if (await hasStagedChanges()) {
                 logger.verbose('Staged dependency changes found, creating commit...');
-                await execute$1(runConfig);
+                // Commit also needs git lock
+                await runGitWithLock(process.cwd(), async ()=>{
+                    await execute$2(runConfig);
+                }, 'commit dependency updates');
             } else {
                 logger.verbose('No dependency changes to commit, skipping commit.');
             }
@@ -586,102 +599,105 @@ const execute = async (runConfig)=>{
             if (isDryRun) {
                 logger.info(`Would merge ${targetBranch} into current branch`);
             } else {
-                // Fetch the latest target branch
-                try {
-                    await run(`git fetch origin ${targetBranch}:${targetBranch}`);
-                    logger.info(`✅ Fetched latest ${targetBranch}`);
-                } catch (fetchError) {
-                    logger.warn(`⚠️ Could not fetch ${targetBranch}: ${fetchError.message}`);
-                    logger.warn('Continuing without merge - PR may have conflicts...');
-                }
-                // Check if merge is needed (avoid unnecessary merge commits)
-                try {
-                    const { stdout: mergeBase } = await run(`git merge-base HEAD ${targetBranch}`);
-                    const { stdout: targetCommit } = await run(`git rev-parse ${targetBranch}`);
-                    if (mergeBase.trim() === targetCommit.trim()) {
-                        logger.info(`ℹ️  Already up-to-date with ${targetBranch}, no merge needed`);
-                    } else {
-                        // Try to merge target branch into current branch
-                        let mergeSucceeded = false;
-                        try {
-                            await run(`git merge ${targetBranch} --no-edit -m "Merge ${targetBranch} to sync before version bump"`);
-                            logger.info(`✅ Merged ${targetBranch} into current branch`);
-                            mergeSucceeded = true;
-                        } catch (mergeError) {
-                            // If merge conflicts occur, check if they're only in version-related files
-                            const errorText = [
-                                mergeError.message || '',
-                                mergeError.stdout || '',
-                                mergeError.stderr || ''
-                            ].join(' ');
-                            if (errorText.includes('CONFLICT')) {
-                                logger.warn(`⚠️  Merge conflicts detected, attempting automatic resolution...`);
-                                // Get list of conflicted files
-                                const { stdout: conflictedFiles } = await run('git diff --name-only --diff-filter=U');
-                                const conflicts = conflictedFiles.trim().split('\n').filter(Boolean);
-                                logger.verbose(`Conflicted files: ${conflicts.join(', ')}`);
-                                // Check if conflicts are only in package.json and package-lock.json
-                                const versionFiles = [
-                                    'package.json',
-                                    'package-lock.json'
-                                ];
-                                const nonVersionConflicts = conflicts.filter((f)=>!versionFiles.includes(f));
-                                if (nonVersionConflicts.length > 0) {
-                                    logger.error(`❌ Cannot auto-resolve: conflicts in non-version files: ${nonVersionConflicts.join(', ')}`);
-                                    logger.error('');
-                                    logger.error('Please resolve conflicts manually:');
-                                    logger.error('   1. Resolve conflicts in the files listed above');
-                                    logger.error('   2. git add <resolved-files>');
-                                    logger.error('   3. git commit');
-                                    logger.error('   4. kodrdriv publish (to continue)');
-                                    logger.error('');
-                                    throw new Error(`Merge conflicts in non-version files. Please resolve manually.`);
-                                }
-                                // Auto-resolve version conflicts by accepting current branch versions
-                                // (keep our working branch's version, which is likely already updated)
-                                logger.info(`Auto-resolving version conflicts by keeping current branch versions...`);
-                                for (const file of conflicts){
-                                    if (versionFiles.includes(file)) {
-                                        await run(`git checkout --ours ${file}`);
-                                        await run(`git add ${file}`);
-                                        logger.verbose(`Resolved ${file} using current branch version`);
+                // Wrap entire merge process with git lock (involves fetch, merge, checkout, add, commit)
+                await runGitWithLock(process.cwd(), async ()=>{
+                    // Fetch the latest target branch
+                    try {
+                        await run(`git fetch origin ${targetBranch}:${targetBranch}`);
+                        logger.info(`✅ Fetched latest ${targetBranch}`);
+                    } catch (fetchError) {
+                        logger.warn(`⚠️ Could not fetch ${targetBranch}: ${fetchError.message}`);
+                        logger.warn('Continuing without merge - PR may have conflicts...');
+                    }
+                    // Check if merge is needed (avoid unnecessary merge commits)
+                    try {
+                        const { stdout: mergeBase } = await run(`git merge-base HEAD ${targetBranch}`);
+                        const { stdout: targetCommit } = await run(`git rev-parse ${targetBranch}`);
+                        if (mergeBase.trim() === targetCommit.trim()) {
+                            logger.info(`ℹ️  Already up-to-date with ${targetBranch}, no merge needed`);
+                        } else {
+                            // Try to merge target branch into current branch
+                            let mergeSucceeded = false;
+                            try {
+                                await run(`git merge ${targetBranch} --no-edit -m "Merge ${targetBranch} to sync before version bump"`);
+                                logger.info(`✅ Merged ${targetBranch} into current branch`);
+                                mergeSucceeded = true;
+                            } catch (mergeError) {
+                                // If merge conflicts occur, check if they're only in version-related files
+                                const errorText = [
+                                    mergeError.message || '',
+                                    mergeError.stdout || '',
+                                    mergeError.stderr || ''
+                                ].join(' ');
+                                if (errorText.includes('CONFLICT')) {
+                                    logger.warn(`⚠️  Merge conflicts detected, attempting automatic resolution...`);
+                                    // Get list of conflicted files
+                                    const { stdout: conflictedFiles } = await run('git diff --name-only --diff-filter=U');
+                                    const conflicts = conflictedFiles.trim().split('\n').filter(Boolean);
+                                    logger.verbose(`Conflicted files: ${conflicts.join(', ')}`);
+                                    // Check if conflicts are only in package.json and package-lock.json
+                                    const versionFiles = [
+                                        'package.json',
+                                        'package-lock.json'
+                                    ];
+                                    const nonVersionConflicts = conflicts.filter((f)=>!versionFiles.includes(f));
+                                    if (nonVersionConflicts.length > 0) {
+                                        logger.error(`❌ Cannot auto-resolve: conflicts in non-version files: ${nonVersionConflicts.join(', ')}`);
+                                        logger.error('');
+                                        logger.error('Please resolve conflicts manually:');
+                                        logger.error('   1. Resolve conflicts in the files listed above');
+                                        logger.error('   2. git add <resolved-files>');
+                                        logger.error('   3. git commit');
+                                        logger.error('   4. kodrdriv publish (to continue)');
+                                        logger.error('');
+                                        throw new Error(`Merge conflicts in non-version files. Please resolve manually.`);
+                                    }
+                                    // Auto-resolve version conflicts by accepting current branch versions
+                                    // (keep our working branch's version, which is likely already updated)
+                                    logger.info(`Auto-resolving version conflicts by keeping current branch versions...`);
+                                    for (const file of conflicts){
+                                        if (versionFiles.includes(file)) {
+                                            await run(`git checkout --ours ${file}`);
+                                            await run(`git add ${file}`);
+                                            logger.verbose(`Resolved ${file} using current branch version`);
+                                        }
                                     }
+                                    // Complete the merge
+                                    await run(`git commit --no-edit -m "Merge ${targetBranch} to sync before version bump (auto-resolved version conflicts)"`);
+                                    logger.info(`✅ Auto-resolved version conflicts and completed merge`);
+                                    mergeSucceeded = true;
+                                } else {
+                                    // Not a conflict error, re-throw
+                                    throw mergeError;
                                 }
-                                // Complete the merge
-                                await run(`git commit --no-edit -m "Merge ${targetBranch} to sync before version bump (auto-resolved version conflicts)"`);
-                                logger.info(`✅ Auto-resolved version conflicts and completed merge`);
-                                mergeSucceeded = true;
-                            } else {
-                                // Not a conflict error, re-throw
-                                throw mergeError;
                             }
-                        }
-                        // Only run npm install if merge actually happened
-                        if (mergeSucceeded) {
-                            // Run npm install to update package-lock.json based on merged package.json
-                            logger.info('Running npm install after merge...');
-                            await run('npm install');
-                            logger.info('✅ npm install completed');
-                            // Commit any changes from npm install (e.g., package-lock.json updates)
-                            const { stdout: mergeChangesStatus } = await run('git status --porcelain');
-                            if (mergeChangesStatus.trim()) {
-                                logger.verbose('Staging post-merge changes for commit');
-                                // Check if package-lock.json exists before trying to stage it
-                                const packageLockExistsPostMerge = await storage.exists('package-lock.json');
-                                const filesToStagePostMerge = packageLockExistsPostMerge ? 'package.json package-lock.json' : 'package.json';
-                                await run(`git add ${filesToStagePostMerge}`);
-                                if (await hasStagedChanges()) {
-                                    logger.verbose('Committing post-merge changes...');
-                                    await execute$1(runConfig);
+                            // Only run npm install if merge actually happened
+                            if (mergeSucceeded) {
+                                // Run npm install to update package-lock.json based on merged package.json
+                                logger.info('Running npm install after merge...');
+                                await run('npm install');
+                                logger.info('✅ npm install completed');
+                                // Commit any changes from npm install (e.g., package-lock.json updates)
+                                const { stdout: mergeChangesStatus } = await run('git status --porcelain');
+                                if (mergeChangesStatus.trim()) {
+                                    logger.verbose('Staging post-merge changes for commit');
+                                    // Check if package-lock.json exists before trying to stage it
+                                    const packageLockExistsPostMerge = await storage.exists('package-lock.json');
+                                    const filesToStagePostMerge = packageLockExistsPostMerge ? 'package.json package-lock.json' : 'package.json';
+                                    await run(`git add ${filesToStagePostMerge}`);
+                                    if (await hasStagedChanges()) {
+                                        logger.verbose('Committing post-merge changes...');
+                                        await execute$2(runConfig);
+                                    }
                                 }
                             }
                         }
+                    } catch (error) {
+                        // Only catch truly unexpected errors here
+                        logger.error(`❌ Unexpected error during merge: ${error.message}`);
+                        throw error;
                     }
-                } catch (error) {
-                    // Only catch truly unexpected errors here
-                    logger.error(`❌ Unexpected error during merge: ${error.message}`);
-                    throw error;
-                }
+                }, `merge ${targetBranch} into current branch`);
             }
         }
         // STEP 4: Determine and set target version AFTER checks, dependency commit, and target branch merge
@@ -739,13 +755,18 @@ const execute = async (runConfig)=>{
         // Check if package-lock.json exists before trying to stage it
         const packageLockExistsVersionBump = await storage.exists('package-lock.json');
         const filesToStageVersionBump = packageLockExistsVersionBump ? 'package.json package-lock.json' : 'package.json';
-        await runWithDryRunSupport(`git add ${filesToStageVersionBump}`, isDryRun);
+        // Wrap git operations with lock
+        await runGitWithLock(process.cwd(), async ()=>{
+            await runWithDryRunSupport(`git add ${filesToStageVersionBump}`, isDryRun);
+        }, 'stage version bump');
         if (isDryRun) {
             logger.verbose('Would create version bump commit');
         } else {
             if (await hasStagedChanges()) {
                 logger.verbose('Creating version bump commit...');
-                await execute$1(runConfig);
+                await runGitWithLock(process.cwd(), async ()=>{
+                    await execute$2(runConfig);
+                }, 'commit version bump');
             } else {
                 logger.verbose('No version changes to commit.');
             }
@@ -779,7 +800,7 @@ const execute = async (runConfig)=>{
         if ((_runConfig_publish11 = runConfig.publish) === null || _runConfig_publish11 === void 0 ? void 0 : _runConfig_publish11.fromMain) {
             logger.verbose('Forcing comparison against main branch for release notes');
         }
-        const releaseSummary = await execute$2(releaseConfig);
+        const releaseSummary = await execute$1(releaseConfig);
         if (isDryRun) {
             logger.info('Would write release notes to RELEASE_NOTES.md and RELEASE_TITLE.md in output directory');
         } else {
@@ -794,7 +815,10 @@ const execute = async (runConfig)=>{
         logger.info('Pushing to origin...');
         // Get current branch name and push explicitly to avoid pushing to wrong remote/branch
         const branchName = await GitHub.getCurrentBranchName();
-        await runWithDryRunSupport(`git push origin ${branchName}`, isDryRun);
+        // Wrap git push with lock
+        await runGitWithLock(process.cwd(), async ()=>{
+            await runWithDryRunSupport(`git push origin ${branchName}`, isDryRun);
+        }, `push ${branchName}`);
         logger.info('Creating pull request...');
         if (isDryRun) {
             logger.info('Would get commit title and create PR with GitHub API');
@@ -889,14 +913,19 @@ const execute = async (runConfig)=>{
         }
     }
     try {
-        await runWithDryRunSupport(`git checkout ${targetBranch}`, isDryRun);
+        // Wrap git checkout and pull with lock
+        await runGitWithLock(process.cwd(), async ()=>{
+            await runWithDryRunSupport(`git checkout ${targetBranch}`, isDryRun);
+        }, `checkout ${targetBranch}`);
         // Sync target branch with remote to avoid conflicts during PR creation
         if (!isDryRun) {
             logger.info(`🔄 Syncing ${targetBranch} with remote to avoid PR conflicts...`);
             try {
                 const remoteExists = await run(`git ls-remote --exit-code --heads origin ${targetBranch}`).then(()=>true).catch(()=>false);
                 if (remoteExists) {
-                    await run(`git pull origin ${targetBranch} --no-edit`);
+                    await runGitWithLock(process.cwd(), async ()=>{
+                        await run(`git pull origin ${targetBranch} --no-edit`);
+                    }, `pull ${targetBranch}`);
                     logger.info(`✅ Synced ${targetBranch} with remote`);
                 } else {
                     logger.info(`ℹ️ No remote ${targetBranch} branch found, will be created on first push`);
@@ -979,18 +1008,22 @@ const execute = async (runConfig)=>{
             if (stdout.trim() === tagName) {
                 logger.info(`Tag ${tagName} already exists locally, skipping tag creation`);
             } else {
-                await runSecure('git', [
-                    'tag',
-                    tagName
-                ]);
+                await runGitWithLock(process.cwd(), async ()=>{
+                    await runSecure('git', [
+                        'tag',
+                        tagName
+                    ]);
+                }, `create tag ${tagName}`);
                 logger.info(`Created local tag: ${tagName}`);
             }
         } catch (error) {
             // If git tag -l fails, create the tag anyway
-            await runSecure('git', [
-                'tag',
-                tagName
-            ]);
+            await runGitWithLock(process.cwd(), async ()=>{
+                await runSecure('git', [
+                    'tag',
+                    tagName
+                ]);
+            }, `create tag ${tagName}`);
             logger.info(`Created local tag: ${tagName}`);
         }
         // Check if tag exists on remote before pushing
@@ -1004,11 +1037,13 @@ const execute = async (runConfig)=>{
             if (stdout.trim()) {
                 logger.info(`Tag ${tagName} already exists on remote, skipping push`);
             } else {
-                await runSecure('git', [
-                    'push',
-                    'origin',
-                    tagName
-                ]);
+                await runGitWithLock(process.cwd(), async ()=>{
+                    await runSecure('git', [
+                        'push',
+                        'origin',
+                        tagName
+                    ]);
+                }, `push tag ${tagName}`);
                 logger.info(`Pushed tag to remote: ${tagName}`);
                 tagWasPushed = true;
             }
@@ -1127,22 +1162,35 @@ const execute = async (runConfig)=>{
     logger.info(`🔄 Syncing source branch with target after publish...`);
     await runWithDryRunSupport(`git checkout ${currentBranch}`, isDryRun);
     if (!isDryRun) {
-        // Merge target into source
+        // Sync target into source
         // Note: With squash merging, fast-forward will fail because commit histories diverge
-        logger.info(`Merging ${targetBranch} into ${currentBranch}...`);
-        // Try fast-forward first (works with merge/rebase methods)
-        const fastForwardResult = await run(`git merge ${targetBranch} --ff-only`).catch(()=>null);
-        if (fastForwardResult) {
-            logger.info(`✅ Fast-forward merged ${targetBranch} into ${currentBranch}`);
+        if (mergeMethod === 'squash') {
+            // For squash merges, reset to target branch to avoid conflicts
+            // The squash merge created a single commit on target that represents all source commits
+            logger.info(`Resetting ${currentBranch} to ${targetBranch} (squash merge)...`);
+            await run(`git reset --hard ${targetBranch}`);
+            logger.info(`✅ Reset ${currentBranch} to ${targetBranch}`);
         } else {
-            // Fast-forward failed - expected when using squash merge method
-            if (mergeMethod === 'squash') {
-                logger.verbose('Fast-forward not possible (expected with squash merge), performing regular merge...');
-            } else {
-                logger.warn(`⚠️  Fast-forward merge failed, performing regular merge...`);
+            // For merge/rebase methods, try to merge target back into source
+            logger.info(`Merging ${targetBranch} into ${currentBranch}...`);
+            // Try fast-forward first (works with merge/rebase methods)
+            // Use runSecure to avoid error output for expected failure
+            let fastForwardSucceeded = false;
+            try {
+                await runSecure('git', [
+                    'merge',
+                    targetBranch,
+                    '--ff-only'
+                ]);
+                fastForwardSucceeded = true;
+                logger.info(`✅ Fast-forward merged ${targetBranch} into ${currentBranch}`);
+            } catch  {
+                logger.verbose(`Fast-forward merge not possible, performing regular merge...`);
+            }
+            if (!fastForwardSucceeded) {
+                await run(`git merge ${targetBranch} --no-edit`);
+                logger.info(`✅ Merged ${targetBranch} into ${currentBranch}`);
             }
-            await run(`git merge ${targetBranch} --no-edit`);
-            logger.info(`✅ Merged ${targetBranch} into ${currentBranch}`);
         }
         // Determine version bump based on branch configuration
         let versionCommand = 'prepatch'; // Default
@@ -1171,14 +1219,20 @@ const execute = async (runConfig)=>{
         // Push updated source branch
         logger.info(`Pushing updated ${currentBranch} branch...`);
         try {
-            await run(`git push origin ${currentBranch}`);
+            await runGitWithLock(process.cwd(), async ()=>{
+                await run(`git push origin ${currentBranch}`);
+            }, `push ${currentBranch}`);
             logger.info(`✅ Pushed ${currentBranch} to origin`);
         } catch (pushError) {
             logger.warn(`⚠️  Failed to push ${currentBranch}: ${pushError.message}`);
             logger.warn(`   Please push manually: git push origin ${currentBranch}`);
         }
     } else {
-        logger.info(`Would merge ${targetBranch} into ${currentBranch} with --ff-only`);
+        if (mergeMethod === 'squash') {
+            logger.info(`Would reset ${currentBranch} to ${targetBranch} (squash merge)`);
+        } else {
+            logger.info(`Would merge ${targetBranch} into ${currentBranch} with --ff-only`);
+        }
         logger.info(`Would bump version to next development version`);
         logger.info(`Would push ${currentBranch} to origin`);
     }