@eldrforge/kodrdriv 1.2.7 → 1.2.10-dev.0

package/dist/commands/publish.js

@@ -3,13 +3,13 @@ import { execute as execute$1 } from './commit.js';
 import { hasStagedChanges } from '../content/diff.js';
 import { execute as execute$2 } from './release.js';
 import { getDryRunLogger, getLogger } from '../logging.js';
-import { runWithDryRunSupport, run, runSecure, validateGitRef } from '../util/child.js';
+import { run, runSecure, runWithDryRunSupport, validateGitRef } from '../util/child.js';
 import { getCurrentBranchName, findOpenPullRequestByHeadRef, createPullRequest, waitForPullRequestChecks, mergePullRequest, createRelease, closeMilestoneForVersion, getWorkflowsTriggeredByRelease, waitForReleaseWorkflows } from '../util/github.js';
 import { create } from '../util/storage.js';
-import { calculateTargetVersion, checkIfTagExists, confirmVersionInteractively, getOutputPath } from '../util/general.js';
+import { calculateBranchDependentVersion, calculateTargetVersion, checkIfTagExists, confirmVersionInteractively, getOutputPath } from '../util/general.js';
 import { DEFAULT_OUTPUT_DIRECTORY, KODRDRIV_DEFAULTS } from '../constants.js';
 import { safeJsonParse, validatePackageJson } from '../util/validation.js';
-import { safeSyncBranchWithRemote, localBranchExists, isBranchInSyncWithRemote } from '../util/git.js';
+import { localBranchExists, safeSyncBranchWithRemote, isBranchInSyncWithRemote } from '../util/git.js';
 
 const scanNpmrcForEnvVars = async (storage)=>{
     const logger = getLogger();
@@ -55,7 +55,7 @@ const validateEnvironmentVariables = (requiredEnvVars, isDryRun)=>{
         }
     }
 };
-const runPrechecks = async (runConfig)=>{
+const runPrechecks = async (runConfig, targetBranch)=>{
     var _runConfig_publish, _runConfig_publish1;
     const isDryRun = runConfig.dryRun || false;
     const logger = getDryRunLogger(isDryRun);
@@ -95,28 +95,29 @@ const runPrechecks = async (runConfig)=>{
             throw new Error(`Failed to check git status: ${originalMessage}. Please ensure you are in a valid git repository and try again.`);
         }
     }
+    // Use the passed target branch or fallback to config/default
+    const effectiveTargetBranch = targetBranch || ((_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.targetBranch) || 'main';
     // Check that we're not running from the target branch
     logger.info('Checking current branch...');
-    const targetBranch = ((_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.targetBranch) || 'main';
     if (isDryRun) {
-        logger.info(`Would verify current branch is not the target branch (${targetBranch})`);
+        logger.info(`Would verify current branch is not the target branch (${effectiveTargetBranch})`);
     } else {
         const currentBranch = await getCurrentBranchName();
-        if (currentBranch === targetBranch) {
-            throw new Error(`Cannot run publish from the target branch '${targetBranch}'. Please switch to a different branch before running publish.`);
+        if (currentBranch === effectiveTargetBranch) {
+            throw new Error(`Cannot run publish from the target branch '${effectiveTargetBranch}'. Please switch to a different branch before running publish.`);
         }
     }
     // Check target branch sync with remote
-    logger.info(`Checking target branch '${targetBranch}' sync with remote...`);
+    logger.info(`Checking target branch '${effectiveTargetBranch}' sync with remote...`);
     if (isDryRun) {
-        logger.info(`Would verify target branch '${targetBranch}' is in sync with remote origin`);
+        logger.info(`Would verify target branch '${effectiveTargetBranch}' is in sync with remote origin`);
     } else {
         // Only check if local target branch exists (it's okay if it doesn't exist locally)
-        const targetBranchExists = await localBranchExists(targetBranch);
+        const targetBranchExists = await localBranchExists(effectiveTargetBranch);
         if (targetBranchExists) {
-            const syncStatus = await isBranchInSyncWithRemote(targetBranch);
+            const syncStatus = await isBranchInSyncWithRemote(effectiveTargetBranch);
             if (!syncStatus.inSync) {
-                logger.error(`❌ Target branch '${targetBranch}' is not in sync with remote.`);
+                logger.error(`❌ Target branch '${effectiveTargetBranch}' is not in sync with remote.`);
                 logger.error('');
                 if (syncStatus.error) {
                     logger.error(`   Error: ${syncStatus.error}`);
@@ -126,18 +127,18 @@ const runPrechecks = async (runConfig)=>{
                 }
                 logger.error('');
                 logger.error('📋 To resolve this issue:');
-                logger.error(`   1. Switch to the target branch: git checkout ${targetBranch}`);
-                logger.error(`   2. Pull the latest changes: git pull origin ${targetBranch}`);
+                logger.error(`   1. Switch to the target branch: git checkout ${effectiveTargetBranch}`);
+                logger.error(`   2. Pull the latest changes: git pull origin ${effectiveTargetBranch}`);
                 logger.error('   3. Resolve any merge conflicts if they occur');
                 logger.error('   4. Switch back to your feature branch and re-run publish');
                 logger.error('');
                 logger.error('💡 Alternatively, run "kodrdriv publish --sync-target" to attempt automatic sync.');
-                throw new Error(`Target branch '${targetBranch}' is not in sync with remote. Please sync the branch before running publish.`);
+                throw new Error(`Target branch '${effectiveTargetBranch}' is not in sync with remote. Please sync the branch before running publish.`);
             } else {
-                logger.info(`✅ Target branch '${targetBranch}' is in sync with remote.`);
+                logger.info(`✅ Target branch '${effectiveTargetBranch}' is in sync with remote.`);
             }
         } else {
-            logger.info(`ℹ️  Target branch '${targetBranch}' does not exist locally - will be created when needed.`);
+            logger.info(`ℹ️  Target branch '${effectiveTargetBranch}' does not exist locally - will be created when needed.`);
         }
     }
     // Check if prepublishOnly script exists in package.json
@@ -208,6 +209,22 @@ const isReleaseNecessaryComparedToTarget = async (targetBranch, isDryRun)=>{
     const logger = getDryRunLogger(isDryRun);
     // We compare current HEAD branch to the provided target branch
     const currentBranch = await getCurrentBranchName();
+    // Check if target branch exists before trying to compare
+    try {
+        // Validate target branch exists and is accessible
+        await runSecure('git', [
+            'rev-parse',
+            '--verify',
+            targetBranch
+        ]);
+    } catch (error) {
+        // Target branch doesn't exist or isn't accessible
+        logger.verbose(`Target branch '${targetBranch}' does not exist or is not accessible. Proceeding with publish.`);
+        return {
+            necessary: true,
+            reason: `Target branch '${targetBranch}' does not exist; first release to this branch`
+        };
+    }
     // If branches are identical, nothing to release
     const { stdout: namesStdout } = await runSecure('git', [
         'diff',
@@ -268,11 +285,9 @@ const isReleaseNecessaryComparedToTarget = async (targetBranch, isDryRun)=>{
         };
     }
 };
-const handleTargetBranchSyncRecovery = async (runConfig)=>{
-    var _runConfig_publish;
+const handleTargetBranchSyncRecovery = async (runConfig, targetBranch)=>{
     const isDryRun = runConfig.dryRun || false;
     const logger = getDryRunLogger(isDryRun);
-    const targetBranch = ((_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.targetBranch) || 'main';
     logger.info(`🔄 Attempting to sync target branch '${targetBranch}' with remote...`);
     if (isDryRun) {
         logger.info(`Would attempt to sync '${targetBranch}' with remote`);
@@ -304,14 +319,105 @@ const execute = async (runConfig)=>{
     const storage = create({
         log: logger.info
     });
-    const targetBranch = ((_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.targetBranch) || 'main';
+    // Get current branch for branch-dependent targeting
+    let currentBranch;
+    if (isDryRun) {
+        currentBranch = 'mock-branch';
+    } else {
+        currentBranch = await getCurrentBranchName();
+        // Fetch latest remote information to avoid conflicts
+        logger.info('📡 Fetching latest remote information to avoid conflicts...');
+        try {
+            await run('git fetch origin');
+            logger.info('✅ Fetched latest remote information');
+        } catch (error) {
+            logger.warn(`⚠️ Could not fetch from remote: ${error.message}`);
+        }
+        // Sync current branch with remote to avoid conflicts
+        logger.info(`🔄 Syncing ${currentBranch} with remote to avoid conflicts...`);
+        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`);
+                logger.info(`✅ Synced ${currentBranch} with remote`);
+            } else {
+                logger.info(`ℹ️ No remote ${currentBranch} branch found, will be created on first push`);
+            }
+        } catch (error) {
+            if (error.message && error.message.includes('CONFLICT')) {
+                logger.error(`❌ Merge conflicts detected when syncing ${currentBranch} with remote`);
+                logger.error(`   Please resolve the conflicts manually and then run:`);
+                logger.error(`   1. Resolve conflicts in the files`);
+                logger.error(`   2. git add <resolved-files>`);
+                logger.error(`   3. git commit`);
+                logger.error(`   4. kodrdriv publish (to continue)`);
+                throw new Error(`Merge conflicts detected when syncing ${currentBranch} with remote. Please resolve conflicts manually.`);
+            } else {
+                logger.warn(`⚠️ Could not sync with remote ${currentBranch}: ${error.message}`);
+            }
+        }
+    }
+    // Determine target branch and version strategy based on branch configuration
+    let targetBranch = ((_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.targetBranch) || 'main';
+    let branchDependentVersioning = false;
+    // Check for branches configuration
+    if (runConfig.branches && runConfig.branches[currentBranch]) {
+        branchDependentVersioning = true;
+        const branchConfig = runConfig.branches[currentBranch];
+        if (branchConfig.targetBranch) {
+            targetBranch = branchConfig.targetBranch;
+        }
+        logger.info(`🎯 Branch-dependent targeting enabled:`);
+        logger.info(`   Source branch: ${currentBranch}`);
+        logger.info(`   Target branch: ${targetBranch}`);
+        // Look at target branch config to show version strategy
+        const targetBranchConfig = runConfig.branches[targetBranch];
+        if (targetBranchConfig === null || targetBranchConfig === void 0 ? void 0 : targetBranchConfig.version) {
+            const versionType = targetBranchConfig.version.type;
+            const versionTag = targetBranchConfig.version.tag;
+            const versionIncrement = targetBranchConfig.version.increment;
+            logger.info(`   Target branch version strategy: ${versionType}${versionTag ? ` (tag: ${versionTag})` : ''}${versionIncrement ? ' with increment' : ''}`);
+        }
+    } else {
+        logger.debug(`No branch-specific targeting configured for '${currentBranch}', using default target: ${targetBranch}`);
+    }
     // Handle --sync-target flag
     if ((_runConfig_publish1 = runConfig.publish) === null || _runConfig_publish1 === void 0 ? void 0 : _runConfig_publish1.syncTarget) {
-        await handleTargetBranchSyncRecovery(runConfig);
+        await handleTargetBranchSyncRecovery(runConfig, targetBranch);
         return; // Exit after sync operation
     }
+    // Check if target branch exists and create it if needed
+    logger.info(`Checking if target branch '${targetBranch}' exists...`);
+    if (isDryRun) {
+        logger.info(`Would check if target branch '${targetBranch}' exists and create if needed`);
+    } else {
+        const targetBranchExists = await localBranchExists(targetBranch);
+        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}`);
+            } catch (error) {
+                throw new Error(`Failed to create target branch '${targetBranch}': ${error.message}`);
+            }
+        } else {
+            logger.info(`✅ Target branch '${targetBranch}' already exists`);
+        }
+    }
     // Run prechecks before starting any work
-    await runPrechecks(runConfig);
+    await runPrechecks(runConfig, targetBranch);
     // Early check: determine if a release is necessary compared to target branch
     logger.info('Evaluating if a release is necessary compared to target branch...');
     try {
@@ -370,27 +476,142 @@ const execute = async (runConfig)=>{
                 logger.verbose('No dependency changes to commit, skipping commit.');
             }
         }
-        // STEP 3: Determine and set target version AFTER checks and dependency 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`);
+        } 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;
+                        }
+                    }
+                    // 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;
+            }
+        }
+        // STEP 4: Determine and set target version AFTER checks, dependency commit, and target branch merge
         logger.info('Determining target version...');
         let newVersion;
         if (isDryRun) {
             logger.info('Would determine target version and update package.json');
             newVersion = '1.0.0'; // Mock version for dry run
         } else {
-            var _runConfig_publish8, _runConfig_publish9;
+            var _runConfig_publish8;
             const packageJsonContents = await storage.readFile('package.json', 'utf-8');
             const parsed = safeJsonParse(packageJsonContents, 'package.json');
             const packageJson = validatePackageJson(parsed, 'package.json');
             const currentVersion = packageJson.version;
-            const targetVersionInput = ((_runConfig_publish8 = runConfig.publish) === null || _runConfig_publish8 === void 0 ? void 0 : _runConfig_publish8.targetVersion) || 'patch';
-            const proposedVersion = calculateTargetVersion(currentVersion, targetVersionInput);
+            let proposedVersion;
+            let finalTargetBranch = targetBranch;
+            if (branchDependentVersioning && runConfig.branches) {
+                // Use branch-dependent versioning logic
+                const branchDependentResult = await calculateBranchDependentVersion(currentVersion, currentBranch, runConfig.branches, targetBranch);
+                proposedVersion = branchDependentResult.version;
+                finalTargetBranch = branchDependentResult.targetBranch;
+                logger.info(`🎯 Branch-dependent version calculated: ${currentVersion} → ${proposedVersion}`);
+                logger.info(`🎯 Final target branch: ${finalTargetBranch}`);
+                // Update targetBranch for the rest of the function
+                targetBranch = finalTargetBranch;
+            } else {
+                var _runConfig_publish9;
+                // Use existing logic for backward compatibility
+                const targetVersionInput = ((_runConfig_publish9 = runConfig.publish) === null || _runConfig_publish9 === void 0 ? void 0 : _runConfig_publish9.targetVersion) || 'patch';
+                proposedVersion = calculateTargetVersion(currentVersion, targetVersionInput);
+            }
             const targetTagName = `v${proposedVersion}`;
             const tagExists = await checkIfTagExists(targetTagName);
             if (tagExists) {
                 throw new Error(`Tag ${targetTagName} already exists. Please choose a different version or delete the existing tag.`);
             }
-            if ((_runConfig_publish9 = runConfig.publish) === null || _runConfig_publish9 === void 0 ? void 0 : _runConfig_publish9.interactive) {
-                newVersion = await confirmVersionInteractively(currentVersion, proposedVersion, targetVersionInput);
+            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);
                 const confirmedTagName = `v${newVersion}`;
                 const confirmedTagExists = await checkIfTagExists(confirmedTagName);
                 if (confirmedTagExists) {
@@ -404,7 +625,7 @@ const execute = async (runConfig)=>{
             await storage.writeFile('package.json', JSON.stringify(packageJson, null, 2) + '\n', 'utf-8');
             logger.info(`Version updated in package.json: ${newVersion}`);
         }
-        // STEP 4: Commit version bump as a separate commit
+        // STEP 5: Commit version bump as a separate commit
         logger.verbose('Staging version bump for commit');
         await runWithDryRunSupport('git add package.json package-lock.json', isDryRun);
         if (isDryRun) {
@@ -460,8 +681,8 @@ const execute = async (runConfig)=>{
         }
         logger.info('Pushing to origin...');
         // Get current branch name and push explicitly to avoid pushing to wrong remote/branch
-        const currentBranch = await getCurrentBranchName();
-        await runWithDryRunSupport(`git push origin ${currentBranch}`, isDryRun);
+        const branchName = await getCurrentBranchName();
+        await runWithDryRunSupport(`git push origin ${branchName}`, isDryRun);
         logger.info('Creating pull request...');
         if (isDryRun) {
             logger.info('Would get commit title and create PR with GitHub API');
@@ -472,21 +693,21 @@ const execute = async (runConfig)=>{
             };
         } else {
             const { stdout: commitTitle } = await run('git log -1 --pretty=%B');
-            pr = await createPullRequest(commitTitle, 'Automated release PR.', await getCurrentBranchName());
+            pr = await createPullRequest(commitTitle, 'Automated release PR.', branchName, targetBranch);
             if (!pr) {
                 throw new Error('Failed to create pull request.');
             }
-            logger.info(`Pull request created: ${pr.html_url}`);
+            logger.info(`Pull request created: ${pr.html_url} (${branchName} → ${targetBranch})`);
         }
     }
     logger.info(`Waiting for PR #${pr.number} checks to complete...`);
     if (!isDryRun) {
-        var _runConfig_publish10, _runConfig_publish11, _runConfig_publish12;
+        var _runConfig_publish11, _runConfig_publish12, _runConfig_publish13;
         // Configure timeout and user confirmation behavior
-        const timeout = ((_runConfig_publish10 = runConfig.publish) === null || _runConfig_publish10 === void 0 ? void 0 : _runConfig_publish10.checksTimeout) || KODRDRIV_DEFAULTS.publish.checksTimeout;
-        const senditMode = ((_runConfig_publish11 = runConfig.publish) === null || _runConfig_publish11 === void 0 ? void 0 : _runConfig_publish11.sendit) || false;
+        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;
         // sendit flag overrides skipUserConfirmation - if sendit is true, skip confirmation
-        const skipUserConfirmation = senditMode || ((_runConfig_publish12 = runConfig.publish) === null || _runConfig_publish12 === void 0 ? void 0 : _runConfig_publish12.skipUserConfirmation) || false;
+        const skipUserConfirmation = senditMode || ((_runConfig_publish13 = runConfig.publish) === null || _runConfig_publish13 === void 0 ? void 0 : _runConfig_publish13.skipUserConfirmation) || false;
         await waitForPullRequestChecks(pr.number, {
             timeout,
             skipUserConfirmation
@@ -539,7 +760,37 @@ const execute = async (runConfig)=>{
     }
     try {
         await runWithDryRunSupport(`git checkout ${targetBranch}`, isDryRun);
-        await runWithDryRunSupport(`git pull origin ${targetBranch}`, isDryRun);
+        // 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`);
+                    logger.info(`✅ Synced ${targetBranch} with remote`);
+                } else {
+                    logger.info(`ℹ️ No remote ${targetBranch} branch found, will be created on first push`);
+                }
+            } catch (syncError) {
+                if (syncError.message && syncError.message.includes('CONFLICT')) {
+                    logger.error(`❌ Merge conflicts detected when syncing ${targetBranch} with remote`);
+                    logger.error(`   Please resolve the conflicts manually:`);
+                    logger.error(`   1. git checkout ${targetBranch}`);
+                    logger.error(`   2. git pull origin ${targetBranch}`);
+                    logger.error(`   3. Resolve conflicts in the files`);
+                    logger.error(`   4. git add <resolved-files>`);
+                    logger.error(`   5. git commit`);
+                    logger.error(`   6. git checkout ${currentBranch}`);
+                    logger.error(`   7. kodrdriv publish (to continue)`);
+                    throw syncError;
+                } else {
+                    logger.warn(`⚠️ Could not sync ${targetBranch} with remote: ${syncError.message}`);
+                // Continue with publish process, but log the warning
+                }
+            }
+        } else {
+            logger.info(`Would sync ${targetBranch} with remote to avoid PR conflicts`);
+        }
     } catch (error) {
         // Check if this is a merge conflict or sync issue
         if (!isDryRun && (error.message.includes('conflict') || error.message.includes('CONFLICT') || error.message.includes('diverged') || error.message.includes('non-fast-forward'))) {
@@ -657,9 +908,9 @@ const execute = async (runConfig)=>{
     }
     logger.info('Creating GitHub release...');
     if (isDryRun) {
-        var _runConfig_publish13;
+        var _runConfig_publish14;
         logger.info('Would read package.json version and create GitHub release with retry logic');
-        const milestonesEnabled = !((_runConfig_publish13 = runConfig.publish) === null || _runConfig_publish13 === void 0 ? void 0 : _runConfig_publish13.noMilestones);
+        const milestonesEnabled = !((_runConfig_publish14 = runConfig.publish) === null || _runConfig_publish14 === void 0 ? void 0 : _runConfig_publish14.noMilestones);
         if (milestonesEnabled) {
             logger.info('Would close milestone for released version');
         } else {
@@ -675,11 +926,11 @@ const execute = async (runConfig)=>{
         let retries = 3;
         while(retries > 0){
             try {
-                var _runConfig_publish14;
+                var _runConfig_publish15;
                 await createRelease(tagName, releaseTitle, releaseNotesContent);
                 logger.info(`GitHub release created successfully for tag: ${tagName}`);
                 // Close milestone for this version if enabled
-                const milestonesEnabled = !((_runConfig_publish14 = runConfig.publish) === null || _runConfig_publish14 === void 0 ? void 0 : _runConfig_publish14.noMilestones);
+                const milestonesEnabled = !((_runConfig_publish15 = runConfig.publish) === null || _runConfig_publish15 === void 0 ? void 0 : _runConfig_publish15.noMilestones);
                 if (milestonesEnabled) {
                     logger.info('🏁 Closing milestone for released version...');
                     const version = tagName.replace(/^v/, ''); // Remove 'v' prefix if present
@@ -712,12 +963,12 @@ const execute = async (runConfig)=>{
         if (isDryRun) {
             logger.info('Would monitor GitHub Actions workflows triggered by release');
         } else {
-            var _runConfig_publish15, _runConfig_publish16, _runConfig_publish17, _runConfig_publish18;
-            const workflowTimeout = ((_runConfig_publish15 = runConfig.publish) === null || _runConfig_publish15 === void 0 ? void 0 : _runConfig_publish15.releaseWorkflowsTimeout) || KODRDRIV_DEFAULTS.publish.releaseWorkflowsTimeout;
-            const senditMode = ((_runConfig_publish16 = runConfig.publish) === null || _runConfig_publish16 === void 0 ? void 0 : _runConfig_publish16.sendit) || false;
-            const skipUserConfirmation = senditMode || ((_runConfig_publish17 = runConfig.publish) === null || _runConfig_publish17 === void 0 ? void 0 : _runConfig_publish17.skipUserConfirmation) || false;
+            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;
             // Get workflow names - either from config or auto-detect
-            let workflowNames = (_runConfig_publish18 = runConfig.publish) === null || _runConfig_publish18 === void 0 ? void 0 : _runConfig_publish18.releaseWorkflowNames;
+            let workflowNames = (_runConfig_publish19 = runConfig.publish) === null || _runConfig_publish19 === void 0 ? void 0 : _runConfig_publish19.releaseWorkflowNames;
             if (!workflowNames || workflowNames.length === 0) {
                 logger.info('No specific workflow names configured, auto-detecting workflows triggered by release events...');
                 try {