@eldrforge/kodrdriv 1.2.12 → 1.2.14

package/dist/commands/publish.js

@@ -446,7 +446,7 @@ const execute = async (runConfig)=>{
     if (pr) {
         logger.info(`Found existing pull request for branch: ${pr.html_url}`);
     } else {
-        var _runConfig_publish4, _runConfig_publish5, _runConfig_publish6, _runConfig_publish7;
+        var _runConfig_publish4, _runConfig_publish5, _runConfig_publish6, _runConfig_publish7, _runConfig_publish8, _runConfig_publish9, _runConfig_publish10, _runConfig_publish11;
         logger.info('No open pull request found, starting new release publishing process...');
         // STEP 1: Prepare for release (update dependencies and run prepublish checks) with NO version bump yet
         logger.verbose('Preparing for release: switching from workspace to remote dependencies.');
@@ -476,103 +476,108 @@ const execute = async (runConfig)=>{
                 logger.verbose('No dependency changes to commit, skipping commit.');
             }
         }
-        // STEP 3: Merge target branch into working branch to avoid conflicts
-        logger.info(`Merging target branch '${targetBranch}' into current branch to avoid version conflicts...`);
-        if (isDryRun) {
-            logger.info(`Would merge ${targetBranch} into current branch`);
+        // STEP 3: Merge target branch into working branch (optional - now skipped by default since post-publish sync keeps branches in sync)
+        const skipPreMerge = ((_runConfig_publish5 = runConfig.publish) === null || _runConfig_publish5 === void 0 ? void 0 : _runConfig_publish5.skipPrePublishMerge) !== false; // Default to true (skip)
+        if (skipPreMerge) {
+            logger.verbose(`⏭️  Skipping pre-publish merge (post-publish sync will handle branch synchronization)`);
         } 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`);
+            logger.info(`Merging target branch '${targetBranch}' into current branch to avoid version conflicts...`);
+            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`);
+                                    }
                                 }
+                                // 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');
-                            await run('git add package.json package-lock.json');
-                            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');
+                                await run('git add package.json package-lock.json');
+                                if (await hasStagedChanges()) {
+                                    logger.verbose('Committing post-merge changes...');
+                                    await execute$1(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;
             }
         }
         // STEP 4: Determine and set target version AFTER checks, dependency commit, and target branch merge
@@ -582,7 +587,7 @@ const execute = async (runConfig)=>{
             logger.info('Would determine target version and update package.json');
             newVersion = '1.0.0'; // Mock version for dry run
         } else {
-            var _runConfig_publish8;
+            var _runConfig_publish12;
             const packageJsonContents = await storage.readFile('package.json', 'utf-8');
             const parsed = safeJsonParse(packageJsonContents, 'package.json');
             const packageJson = validatePackageJson(parsed, 'package.json');
@@ -599,9 +604,9 @@ const execute = async (runConfig)=>{
                 // Update targetBranch for the rest of the function
                 targetBranch = finalTargetBranch;
             } else {
-                var _runConfig_publish9;
+                var _runConfig_publish13;
                 // Use existing logic for backward compatibility
-                const targetVersionInput = ((_runConfig_publish9 = runConfig.publish) === null || _runConfig_publish9 === void 0 ? void 0 : _runConfig_publish9.targetVersion) || 'patch';
+                const targetVersionInput = ((_runConfig_publish13 = runConfig.publish) === null || _runConfig_publish13 === void 0 ? void 0 : _runConfig_publish13.targetVersion) || 'patch';
                 proposedVersion = calculateTargetVersion(currentVersion, targetVersionInput);
             }
             const targetTagName = `v${proposedVersion}`;
@@ -609,9 +614,9 @@ const execute = async (runConfig)=>{
             if (tagExists) {
                 throw new Error(`Tag ${targetTagName} already exists. Please choose a different version or delete the existing tag.`);
             }
-            if ((_runConfig_publish8 = runConfig.publish) === null || _runConfig_publish8 === void 0 ? void 0 : _runConfig_publish8.interactive) {
-                var _runConfig_publish10;
-                newVersion = await confirmVersionInteractively(currentVersion, proposedVersion, (_runConfig_publish10 = runConfig.publish) === null || _runConfig_publish10 === void 0 ? void 0 : _runConfig_publish10.targetVersion);
+            if ((_runConfig_publish12 = runConfig.publish) === null || _runConfig_publish12 === void 0 ? void 0 : _runConfig_publish12.interactive) {
+                var _runConfig_publish14;
+                newVersion = await confirmVersionInteractively(currentVersion, proposedVersion, (_runConfig_publish14 = runConfig.publish) === null || _runConfig_publish14 === void 0 ? void 0 : _runConfig_publish14.targetVersion);
                 const confirmedTagName = `v${newVersion}`;
                 const confirmedTagExists = await checkIfTagExists(confirmedTagName);
                 if (confirmedTagExists) {
@@ -639,33 +644,33 @@ const execute = async (runConfig)=>{
             }
         }
         logger.info('Generating release notes...');
+        // Use the existing currentBranch variable for tag detection
+        logger.debug(`Current branch for release notes: ${currentBranch}`);
         // Create a modified config for release notes generation that includes the publish --from, --interactive, and --from-main options
         const releaseConfig = {
             ...runConfig
         };
-        if (((_runConfig_publish5 = runConfig.publish) === null || _runConfig_publish5 === void 0 ? void 0 : _runConfig_publish5.from) || ((_runConfig_publish6 = runConfig.publish) === null || _runConfig_publish6 === void 0 ? void 0 : _runConfig_publish6.interactive) || ((_runConfig_publish7 = runConfig.publish) === null || _runConfig_publish7 === void 0 ? void 0 : _runConfig_publish7.fromMain)) {
-            // Pass the publish options to the release config
-            releaseConfig.release = {
-                ...runConfig.release,
-                ...runConfig.publish.from && {
-                    from: runConfig.publish.from
-                },
-                ...runConfig.publish.interactive && {
-                    interactive: runConfig.publish.interactive
-                },
-                ...runConfig.publish.fromMain && {
-                    fromMain: runConfig.publish.fromMain
-                }
-            };
-            if (runConfig.publish.from) {
-                logger.verbose(`Using custom 'from' reference for release notes: ${runConfig.publish.from}`);
-            }
-            if (runConfig.publish.interactive) {
-                logger.verbose('Interactive mode enabled for release notes generation');
-            }
-            if (runConfig.publish.fromMain) {
-                logger.verbose('Forcing comparison against main branch for release notes');
+        releaseConfig.release = {
+            ...runConfig.release,
+            currentBranch: currentBranch,
+            ...((_runConfig_publish6 = runConfig.publish) === null || _runConfig_publish6 === void 0 ? void 0 : _runConfig_publish6.from) && {
+                from: runConfig.publish.from
+            },
+            ...((_runConfig_publish7 = runConfig.publish) === null || _runConfig_publish7 === void 0 ? void 0 : _runConfig_publish7.interactive) && {
+                interactive: runConfig.publish.interactive
+            },
+            ...((_runConfig_publish8 = runConfig.publish) === null || _runConfig_publish8 === void 0 ? void 0 : _runConfig_publish8.fromMain) && {
+                fromMain: runConfig.publish.fromMain
             }
+        };
+        if ((_runConfig_publish9 = runConfig.publish) === null || _runConfig_publish9 === void 0 ? void 0 : _runConfig_publish9.from) {
+            logger.verbose(`Using custom 'from' reference for release notes: ${runConfig.publish.from}`);
+        }
+        if ((_runConfig_publish10 = runConfig.publish) === null || _runConfig_publish10 === void 0 ? void 0 : _runConfig_publish10.interactive) {
+            logger.verbose('Interactive mode enabled for release notes generation');
+        }
+        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);
         if (isDryRun) {
@@ -702,12 +707,12 @@ const execute = async (runConfig)=>{
     }
     logger.info(`Waiting for PR #${pr.number} checks to complete...`);
     if (!isDryRun) {
-        var _runConfig_publish11, _runConfig_publish12, _runConfig_publish13;
+        var _runConfig_publish15, _runConfig_publish16, _runConfig_publish17;
         // Configure timeout and user confirmation behavior
-        const timeout = ((_runConfig_publish11 = runConfig.publish) === null || _runConfig_publish11 === void 0 ? void 0 : _runConfig_publish11.checksTimeout) || KODRDRIV_DEFAULTS.publish.checksTimeout;
-        const senditMode = ((_runConfig_publish12 = runConfig.publish) === null || _runConfig_publish12 === void 0 ? void 0 : _runConfig_publish12.sendit) || false;
+        const timeout = ((_runConfig_publish15 = runConfig.publish) === null || _runConfig_publish15 === void 0 ? void 0 : _runConfig_publish15.checksTimeout) || KODRDRIV_DEFAULTS.publish.checksTimeout;
+        const senditMode = ((_runConfig_publish16 = runConfig.publish) === null || _runConfig_publish16 === void 0 ? void 0 : _runConfig_publish16.sendit) || false;
         // sendit flag overrides skipUserConfirmation - if sendit is true, skip confirmation
-        const skipUserConfirmation = senditMode || ((_runConfig_publish13 = runConfig.publish) === null || _runConfig_publish13 === void 0 ? void 0 : _runConfig_publish13.skipUserConfirmation) || false;
+        const skipUserConfirmation = senditMode || ((_runConfig_publish17 = runConfig.publish) === null || _runConfig_publish17 === void 0 ? void 0 : _runConfig_publish17.skipUserConfirmation) || false;
         await waitForPullRequestChecks(pr.number, {
             timeout,
             skipUserConfirmation
@@ -908,9 +913,9 @@ const execute = async (runConfig)=>{
     }
     logger.info('Creating GitHub release...');
     if (isDryRun) {
-        var _runConfig_publish14;
+        var _runConfig_publish18;
         logger.info('Would read package.json version and create GitHub release with retry logic');
-        const milestonesEnabled = !((_runConfig_publish14 = runConfig.publish) === null || _runConfig_publish14 === void 0 ? void 0 : _runConfig_publish14.noMilestones);
+        const milestonesEnabled = !((_runConfig_publish18 = runConfig.publish) === null || _runConfig_publish18 === void 0 ? void 0 : _runConfig_publish18.noMilestones);
         if (milestonesEnabled) {
             logger.info('Would close milestone for released version');
         } else {
@@ -926,11 +931,11 @@ const execute = async (runConfig)=>{
         let retries = 3;
         while(retries > 0){
             try {
-                var _runConfig_publish15;
+                var _runConfig_publish19;
                 await createRelease(tagName, releaseTitle, releaseNotesContent);
                 logger.info(`GitHub release created successfully for tag: ${tagName}`);
                 // Close milestone for this version if enabled
-                const milestonesEnabled = !((_runConfig_publish15 = runConfig.publish) === null || _runConfig_publish15 === void 0 ? void 0 : _runConfig_publish15.noMilestones);
+                const milestonesEnabled = !((_runConfig_publish19 = runConfig.publish) === null || _runConfig_publish19 === void 0 ? void 0 : _runConfig_publish19.noMilestones);
                 if (milestonesEnabled) {
                     logger.info('🏁 Closing milestone for released version...');
                     const version = tagName.replace(/^v/, ''); // Remove 'v' prefix if present
@@ -963,12 +968,12 @@ const execute = async (runConfig)=>{
         if (isDryRun) {
             logger.info('Would monitor GitHub Actions workflows triggered by release');
         } else {
-            var _runConfig_publish16, _runConfig_publish17, _runConfig_publish18, _runConfig_publish19;
-            const workflowTimeout = ((_runConfig_publish16 = runConfig.publish) === null || _runConfig_publish16 === void 0 ? void 0 : _runConfig_publish16.releaseWorkflowsTimeout) || KODRDRIV_DEFAULTS.publish.releaseWorkflowsTimeout;
-            const senditMode = ((_runConfig_publish17 = runConfig.publish) === null || _runConfig_publish17 === void 0 ? void 0 : _runConfig_publish17.sendit) || false;
-            const skipUserConfirmation = senditMode || ((_runConfig_publish18 = runConfig.publish) === null || _runConfig_publish18 === void 0 ? void 0 : _runConfig_publish18.skipUserConfirmation) || false;
+            var _runConfig_publish20, _runConfig_publish21, _runConfig_publish22, _runConfig_publish23;
+            const workflowTimeout = ((_runConfig_publish20 = runConfig.publish) === null || _runConfig_publish20 === void 0 ? void 0 : _runConfig_publish20.releaseWorkflowsTimeout) || KODRDRIV_DEFAULTS.publish.releaseWorkflowsTimeout;
+            const senditMode = ((_runConfig_publish21 = runConfig.publish) === null || _runConfig_publish21 === void 0 ? void 0 : _runConfig_publish21.sendit) || false;
+            const skipUserConfirmation = senditMode || ((_runConfig_publish22 = runConfig.publish) === null || _runConfig_publish22 === void 0 ? void 0 : _runConfig_publish22.skipUserConfirmation) || false;
             // Get workflow names - either from config or auto-detect
-            let workflowNames = (_runConfig_publish19 = runConfig.publish) === null || _runConfig_publish19 === void 0 ? void 0 : _runConfig_publish19.releaseWorkflowNames;
+            let workflowNames = (_runConfig_publish23 = runConfig.publish) === null || _runConfig_publish23 === void 0 ? void 0 : _runConfig_publish23.releaseWorkflowNames;
             if (!workflowNames || workflowNames.length === 0) {
                 logger.info('No specific workflow names configured, auto-detecting workflows triggered by release events...');
                 try {
@@ -992,10 +997,64 @@ const execute = async (runConfig)=>{
     } else {
         logger.verbose('Skipping waiting for release workflows (disabled in config).');
     }
-    // Switch to target branch
-    logger.info(`Switching to target branch: ${targetBranch}`);
-    await runWithDryRunSupport(`git checkout ${targetBranch}`, isDryRun);
-    logger.info('Publish process complete.');
+    // Switch back to source branch and sync with target
+    logger.info('');
+    logger.info('🔄 Syncing source branch with target after publish...');
+    await runWithDryRunSupport(`git checkout ${currentBranch}`, isDryRun);
+    if (!isDryRun) {
+        // Merge target into source (should be fast-forward since PR just merged)
+        logger.info(`Merging ${targetBranch} into ${currentBranch}...`);
+        try {
+            await run(`git merge ${targetBranch} --ff-only`);
+            logger.info(`✅ Merged ${targetBranch} into ${currentBranch}`);
+        } catch (error) {
+            // If ff-only fails, something is wrong - source diverged somehow
+            logger.error(`❌ Failed to fast-forward merge ${targetBranch} into ${currentBranch}`);
+            logger.error('   This suggests the source branch has commits not in target.');
+            logger.error('   This should not happen after a successful PR merge.');
+            logger.warn('⚠️  Attempting regular merge...');
+            await run(`git merge ${targetBranch} --no-edit`);
+        }
+        // Determine version bump based on branch configuration
+        let versionCommand = 'prepatch'; // Default
+        let versionTag = 'dev'; // Default
+        if (branchDependentVersioning && runConfig.branches) {
+            const sourceBranchConfig = runConfig.branches[currentBranch];
+            if (sourceBranchConfig === null || sourceBranchConfig === void 0 ? void 0 : sourceBranchConfig.version) {
+                // Use configured version strategy for source branch
+                if (sourceBranchConfig.version.increment) {
+                    versionCommand = `pre${sourceBranchConfig.version.increment}`;
+                }
+                if (sourceBranchConfig.version.tag) {
+                    versionTag = sourceBranchConfig.version.tag;
+                }
+            }
+        }
+        // Bump to next development version
+        logger.info(`Bumping to next development version...`);
+        try {
+            const { stdout: newVersion } = await run(`npm version ${versionCommand} --preid=${versionTag}`);
+            logger.info(`✅ Version bumped to: ${newVersion.trim()}`);
+        } catch (versionError) {
+            logger.warn(`⚠️  Failed to bump version: ${versionError.message}`);
+            logger.warn('   You may need to manually bump the version for next development cycle.');
+        }
+        // Push updated source branch
+        logger.info(`Pushing updated ${currentBranch} branch...`);
+        try {
+            await run(`git push origin ${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`);
+        logger.info(`Would bump version to next development version`);
+        logger.info(`Would push ${currentBranch} to origin`);
+    }
+    logger.info('');
+    logger.info(`✅ Publish complete - on ${currentBranch} with next development version`);
 };
 
 export { execute };