@eldrforge/kodrdriv 0.0.51 → 1.2.0

package/dist/commands/publish.js

@@ -1,20 +1,19 @@
-import path from 'path';
-import { execute as execute$2 } from './commit.js';
+import path__default from 'path';
+import { execute as execute$1 } from './commit.js';
 import { hasStagedChanges } from '../content/diff.js';
-import { execute as execute$3 } from './release.js';
-import { execute as execute$4 } from './link.js';
-import { execute as execute$1 } from './unlink.js';
+import { execute as execute$2 } from './release.js';
 import { getDryRunLogger, getLogger } from '../logging.js';
-import { runWithDryRunSupport, run } from '../util/child.js';
-import { getCurrentBranchName, findOpenPullRequestByHeadRef, createPullRequest, waitForPullRequestChecks, mergePullRequest, createRelease, getWorkflowsTriggeredByRelease, waitForReleaseWorkflows } from '../util/github.js';
+import { runWithDryRunSupport, run, validateGitRef, runSecure } 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 { incrementPatchVersion, getOutputPath } from '../util/general.js';
+import { calculateTargetVersion, checkIfTagExists, confirmVersionInteractively, getOutputPath } from '../util/general.js';
 import { DEFAULT_OUTPUT_DIRECTORY } from '../constants.js';
 import { safeJsonParse, validatePackageJson } from '../util/validation.js';
+import { safeSyncBranchWithRemote, localBranchExists, isBranchInSyncWithRemote } from '../util/git.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 {
@@ -57,7 +56,7 @@ const validateEnvironmentVariables = (requiredEnvVars, isDryRun)=>{
     }
 };
 const runPrechecks = async (runConfig)=>{
-    var _runConfig_publish;
+    var _runConfig_publish, _runConfig_publish1;
     const isDryRun = runConfig.dryRun || false;
     const logger = getDryRunLogger(isDryRun);
     const storage = create({
@@ -96,19 +95,54 @@ 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.`);
         }
     }
-    // Check if we're on a release branch
+    // 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 a release branch (starts with "release/")');
+        logger.info(`Would verify current branch is not the target branch (${targetBranch})`);
     } else {
         const currentBranch = await getCurrentBranchName();
-        if (!currentBranch.startsWith('release/')) {
-            throw new Error(`Current branch '${currentBranch}' is not a release branch. Please switch to a release branch (e.g., release/1.0.0) before running publish.`);
+        if (currentBranch === targetBranch) {
+            throw new Error(`Cannot run publish from the target branch '${targetBranch}'. Please switch to a different branch before running publish.`);
+        }
+    }
+    // Check target branch sync with remote
+    logger.info(`Checking target branch '${targetBranch}' sync with remote...`);
+    if (isDryRun) {
+        logger.info(`Would verify target branch '${targetBranch}' 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);
+        if (targetBranchExists) {
+            const syncStatus = await isBranchInSyncWithRemote(targetBranch);
+            if (!syncStatus.inSync) {
+                logger.error(`❌ Target branch '${targetBranch}' is not in sync with remote.`);
+                logger.error('');
+                if (syncStatus.error) {
+                    logger.error(`   Error: ${syncStatus.error}`);
+                } else if (syncStatus.localSha && syncStatus.remoteSha) {
+                    logger.error(`   Local:  ${syncStatus.localSha.substring(0, 8)}`);
+                    logger.error(`   Remote: ${syncStatus.remoteSha.substring(0, 8)}`);
+                }
+                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('   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.`);
+            } else {
+                logger.info(`✅ Target branch '${targetBranch}' is in sync with remote.`);
+            }
+        } else {
+            logger.info(`ℹ️  Target branch '${targetBranch}' does not exist locally - will be created when needed.`);
         }
     }
     // 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.');
@@ -139,7 +173,7 @@ const runPrechecks = async (runConfig)=>{
     }
     // Check required environment variables
     logger.verbose('Checking required environment variables...');
-    const coreRequiredEnvVars = ((_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.requiredEnvVars) || [];
+    const coreRequiredEnvVars = ((_runConfig_publish1 = runConfig.publish) === null || _runConfig_publish1 === void 0 ? void 0 : _runConfig_publish1.requiredEnvVars) || [];
     const npmrcEnvVars = isDryRun ? [] : await scanNpmrcForEnvVars(storage); // Skip .npmrc scan in dry run
     const allRequiredEnvVars = [
         ...new Set([
@@ -155,343 +189,422 @@ const runPrechecks = async (runConfig)=>{
     }
     logger.info('All prechecks passed.');
 };
+const handleTargetBranchSyncRecovery = async (runConfig)=>{
+    var _runConfig_publish;
+    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`);
+        return;
+    }
+    const syncResult = await safeSyncBranchWithRemote(targetBranch);
+    if (syncResult.success) {
+        logger.info(`✅ Successfully synced '${targetBranch}' with remote.`);
+        logger.info('You can now re-run the publish command.');
+    } else if (syncResult.conflictResolutionRequired) {
+        logger.error(`❌ Failed to sync '${targetBranch}': conflicts detected.`);
+        logger.error('');
+        logger.error('📋 Manual conflict resolution required:');
+        logger.error(`   1. Switch to the target branch: git checkout ${targetBranch}`);
+        logger.error(`   2. Pull and resolve conflicts: git pull origin ${targetBranch}`);
+        logger.error('   3. Commit the resolved changes');
+        logger.error('   4. Switch back to your feature branch and re-run publish');
+        logger.error('');
+        throw new Error(`Target branch '${targetBranch}' has conflicts that require manual resolution.`);
+    } else {
+        logger.error(`❌ Failed to sync '${targetBranch}': ${syncResult.error}`);
+        throw new Error(`Failed to sync target branch: ${syncResult.error}`);
+    }
+};
 const execute = async (runConfig)=>{
+    var _runConfig_publish, _runConfig_publish1, _runConfig_publish2, _runConfig_publish3;
     const isDryRun = runConfig.dryRun || false;
     const logger = getDryRunLogger(isDryRun);
     const storage = create({
         log: logger.info
     });
-    // Track whether the publish process completed successfully
-    let publishCompleted = false;
-    // Track whether we've unlinked packages (and thus need to restore them)
-    let packagesUnlinked = false;
+    const targetBranch = ((_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.targetBranch) || 'main';
+    // Handle --sync-target flag
+    if ((_runConfig_publish1 = runConfig.publish) === null || _runConfig_publish1 === void 0 ? void 0 : _runConfig_publish1.syncTarget) {
+        await handleTargetBranchSyncRecovery(runConfig);
+        return; // Exit after sync operation
+    }
     // Run prechecks before starting any work
     await runPrechecks(runConfig);
     logger.info('Starting release process...');
-    try {
-        var _runConfig_publish, _runConfig_publish1, _runConfig_publish2;
-        // Unlink all workspace packages before starting (if enabled)
-        const shouldUnlink = ((_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.unlinkWorkspacePackages) !== false; // default to true
-        if (shouldUnlink) {
-            logger.verbose('Unlinking workspace packages...');
-            await execute$1(runConfig);
-            packagesUnlinked = true;
+    let pr = null;
+    if (isDryRun) {
+        logger.info('Would check for existing pull request');
+        logger.info('Assuming no existing PR found for demo purposes');
+    } else {
+        const branchName = await getCurrentBranchName();
+        pr = await findOpenPullRequestByHeadRef(branchName);
+    }
+    if (pr) {
+        logger.info(`Found existing pull request for branch: ${pr.html_url}`);
+    } else {
+        var _runConfig_publish4, _runConfig_publish5, _runConfig_publish6;
+        logger.info('No open pull request found, starting new release publishing process...');
+        // STEP 1: Determine and set target version FIRST (before any commits)
+        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 {
-            logger.verbose('Skipping unlink workspace packages (disabled in config).');
+            var _runConfig_publish7, _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;
+            // Determine target version based on --targetVersion option
+            const targetVersionInput = ((_runConfig_publish7 = runConfig.publish) === null || _runConfig_publish7 === void 0 ? void 0 : _runConfig_publish7.targetVersion) || 'patch';
+            const proposedVersion = calculateTargetVersion(currentVersion, targetVersionInput);
+            // Check if target tag already exists
+            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.`);
+            }
+            // Interactive confirmation if --interactive flag is set
+            if ((_runConfig_publish8 = runConfig.publish) === null || _runConfig_publish8 === void 0 ? void 0 : _runConfig_publish8.interactive) {
+                newVersion = await confirmVersionInteractively(currentVersion, proposedVersion, targetVersionInput);
+                // Re-check if the confirmed version's tag exists (in case user entered custom version)
+                const confirmedTagName = `v${newVersion}`;
+                const confirmedTagExists = await checkIfTagExists(confirmedTagName);
+                if (confirmedTagExists) {
+                    throw new Error(`Tag ${confirmedTagName} already exists. Please choose a different version or delete the existing tag.`);
+                }
+            } else {
+                newVersion = proposedVersion;
+            }
+            logger.info(`Bumping version from ${currentVersion} to ${newVersion}`);
+            // Update package.json with the new version BEFORE any other operations
+            packageJson.version = newVersion;
+            await storage.writeFile('package.json', JSON.stringify(packageJson, null, 2) + '\n', 'utf-8');
+            logger.info(`Version updated in package.json: ${newVersion}`);
         }
-        let pr = null;
-        if (isDryRun) {
-            logger.info('Would check for existing pull request');
-            logger.info('Assuming no existing PR found for demo purposes');
+        // STEP 2: Prepare for release (with correct version now in package.json)
+        logger.verbose('Preparing for release: switching from workspace to remote dependencies.');
+        logger.verbose('Updating dependencies to latest versions from registry');
+        const updatePatterns = (_runConfig_publish4 = runConfig.publish) === null || _runConfig_publish4 === void 0 ? void 0 : _runConfig_publish4.dependencyUpdatePatterns;
+        if (updatePatterns && updatePatterns.length > 0) {
+            logger.verbose(`Updating dependencies matching patterns: ${updatePatterns.join(', ')}`);
+            const patternsArg = updatePatterns.join(' ');
+            await runWithDryRunSupport(`npm update ${patternsArg}`, isDryRun);
         } else {
-            const branchName = await getCurrentBranchName();
-            pr = await findOpenPullRequestByHeadRef(branchName);
+            logger.verbose('No dependency update patterns specified, updating all dependencies');
+            await runWithDryRunSupport('npm update', isDryRun);
         }
-        if (pr) {
-            logger.info(`Found existing pull request for branch: ${pr.html_url}`);
+        logger.info('Running prepublishOnly script...');
+        await runWithDryRunSupport('npm run prepublishOnly', isDryRun, {}, true); // Use inherited stdio
+        // STEP 3: Stage all changes (version bump + dependencies + any build artifacts)
+        logger.verbose('Staging all changes for release commit');
+        await runWithDryRunSupport('git add package.json package-lock.json', isDryRun);
+        logger.verbose('Checking for staged changes...');
+        if (isDryRun) {
+            logger.verbose('Assuming staged changes exist for demo purposes');
+            logger.verbose('Would create commit...');
+            await execute$1(runConfig);
         } else {
-            var _runConfig_publish3;
-            logger.info('No open pull request found, starting new release publishing process...');
-            // 1. Prepare for release
-            logger.verbose('Preparing for release: switching from workspace to remote dependencies.');
-            logger.verbose('Updating dependencies to latest versions from registry');
-            const updatePatterns = (_runConfig_publish3 = runConfig.publish) === null || _runConfig_publish3 === void 0 ? void 0 : _runConfig_publish3.dependencyUpdatePatterns;
-            if (updatePatterns && updatePatterns.length > 0) {
-                logger.verbose(`Updating dependencies matching patterns: ${updatePatterns.join(', ')}`);
-                const patternsArg = updatePatterns.join(' ');
-                await runWithDryRunSupport(`npm update ${patternsArg}`, isDryRun);
+            if (await hasStagedChanges()) {
+                logger.verbose('Staged changes found, creating commit...');
+                await execute$1(runConfig);
             } else {
-                logger.verbose('No dependency update patterns specified, updating all dependencies');
-                await runWithDryRunSupport('npm update', isDryRun);
+                logger.verbose('No changes to commit, skipping commit.');
             }
-            logger.verbose('Staging changes for release commit');
-            await runWithDryRunSupport('git add package.json package-lock.json', isDryRun);
-            logger.info('Running prepublishOnly script...');
-            await runWithDryRunSupport('npm run prepublishOnly', isDryRun);
-            logger.verbose('Checking for staged changes...');
-            if (isDryRun) {
-                logger.verbose('Assuming staged changes exist for demo purposes');
-                logger.verbose('Would create commit...');
-                await execute$2(runConfig);
-            } else {
-                if (await hasStagedChanges()) {
-                    logger.verbose('Staged changes found, creating commit...');
-                    await execute$2(runConfig);
-                } else {
-                    logger.verbose('No changes to commit, skipping commit.');
+        }
+        logger.info('Generating release notes...');
+        // Create a modified config for release notes generation that includes the publish --from and --interactive 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)) {
+            // Pass the publish --from and --interactive options to the release config
+            releaseConfig.release = {
+                ...runConfig.release,
+                ...runConfig.publish.from && {
+                    from: runConfig.publish.from
+                },
+                ...runConfig.publish.interactive && {
+                    interactive: runConfig.publish.interactive
                 }
+            };
+            if (runConfig.publish.from) {
+                logger.verbose(`Using custom 'from' reference for release notes: ${runConfig.publish.from}`);
             }
-            logger.info('Bumping version...');
-            // Manually increment version without creating a tag
-            if (isDryRun) {
-                logger.info('Would manually increment patch version in package.json and commit');
-            } else {
-                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 newVersion = incrementPatchVersion(currentVersion);
-                packageJson.version = newVersion;
-                await storage.writeFile('package.json', JSON.stringify(packageJson, null, 2) + '\n', 'utf-8');
-                logger.info(`Version bumped from ${currentVersion} to ${newVersion}`);
-                // Stage and commit the version change
-                await run('git add package.json');
-                await run(`git commit -m "chore: bump version to ${newVersion}"`);
-                logger.info(`Version change committed: ${newVersion}`);
+            if (runConfig.publish.interactive) {
+                logger.verbose('Interactive mode enabled for release notes generation');
             }
-            logger.info('Generating release notes...');
-            const releaseSummary = await execute$3(runConfig);
-            if (isDryRun) {
-                logger.info('Would write release notes to RELEASE_NOTES.md and RELEASE_TITLE.md in output directory');
-            } else {
-                const outputDirectory = runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
-                await storage.ensureDirectory(outputDirectory);
-                const releaseNotesPath = getOutputPath(outputDirectory, 'RELEASE_NOTES.md');
-                const releaseTitlePath = getOutputPath(outputDirectory, 'RELEASE_TITLE.md');
-                await storage.writeFile(releaseNotesPath, releaseSummary.body, 'utf-8');
-                await storage.writeFile(releaseTitlePath, releaseSummary.title, 'utf-8');
-                logger.info(`Release notes and title generated and saved to ${releaseNotesPath} and ${releaseTitlePath}.`);
+        }
+        const releaseSummary = await execute$2(releaseConfig);
+        if (isDryRun) {
+            logger.info('Would write release notes to RELEASE_NOTES.md and RELEASE_TITLE.md in output directory');
+        } else {
+            const outputDirectory = runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
+            await storage.ensureDirectory(outputDirectory);
+            const releaseNotesPath = getOutputPath(outputDirectory, 'RELEASE_NOTES.md');
+            const releaseTitlePath = getOutputPath(outputDirectory, 'RELEASE_TITLE.md');
+            await storage.writeFile(releaseNotesPath, releaseSummary.body, 'utf-8');
+            await storage.writeFile(releaseTitlePath, releaseSummary.title, 'utf-8');
+            logger.info(`Release notes and title generated and saved to ${releaseNotesPath} and ${releaseTitlePath}.`);
+        }
+        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);
+        logger.info('Creating pull request...');
+        if (isDryRun) {
+            logger.info('Would get commit title and create PR with GitHub API');
+            pr = {
+                number: 123,
+                html_url: 'https://github.com/mock/repo/pull/123',
+                labels: []
+            };
+        } else {
+            const { stdout: commitTitle } = await run('git log -1 --pretty=%B');
+            pr = await createPullRequest(commitTitle, 'Automated release PR.', await getCurrentBranchName());
+            if (!pr) {
+                throw new Error('Failed to create pull request.');
             }
-            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);
-            logger.info('Creating pull request...');
-            if (isDryRun) {
-                logger.info('Would get commit title and create PR with GitHub API');
-                pr = {
-                    number: 123,
-                    html_url: 'https://github.com/mock/repo/pull/123',
-                    labels: []
-                };
+            logger.info(`Pull request created: ${pr.html_url}`);
+        }
+    }
+    logger.info(`Waiting for PR #${pr.number} checks to complete...`);
+    if (!isDryRun) {
+        var _runConfig_publish9, _runConfig_publish10, _runConfig_publish11;
+        // Configure timeout and user confirmation behavior
+        const timeout = ((_runConfig_publish9 = runConfig.publish) === null || _runConfig_publish9 === void 0 ? void 0 : _runConfig_publish9.checksTimeout) || 300000; // 5 minutes default
+        const senditMode = ((_runConfig_publish10 = runConfig.publish) === null || _runConfig_publish10 === void 0 ? void 0 : _runConfig_publish10.sendit) || false;
+        // sendit flag overrides skipUserConfirmation - if sendit is true, skip confirmation
+        const skipUserConfirmation = senditMode || ((_runConfig_publish11 = runConfig.publish) === null || _runConfig_publish11 === void 0 ? void 0 : _runConfig_publish11.skipUserConfirmation) || false;
+        await waitForPullRequestChecks(pr.number, {
+            timeout,
+            skipUserConfirmation
+        });
+    }
+    const mergeMethod = ((_runConfig_publish2 = runConfig.publish) === null || _runConfig_publish2 === void 0 ? void 0 : _runConfig_publish2.mergeMethod) || 'squash';
+    if (isDryRun) {
+        logger.info(`Would merge PR #${pr.number} using ${mergeMethod} method`);
+    } else {
+        try {
+            await mergePullRequest(pr.number, mergeMethod, false); // Don't delete branch
+        } catch (error) {
+            // Check if this is a merge conflict error
+            if (error.message && (error.message.includes('not mergeable') || error.message.includes('Pull Request is not mergeable') || error.message.includes('merge conflict'))) {
+                logger.error(`❌ Pull Request #${pr.number} has merge conflicts that need to be resolved.`);
+                logger.error('');
+                logger.error('📋 To resolve this issue:');
+                logger.error(`   1. Visit the Pull Request: ${pr.html_url}`);
+                logger.error('   2. Resolve the merge conflicts through GitHub\'s web interface or locally');
+                logger.error('   3. Once conflicts are resolved, re-run the publish command');
+                logger.error('');
+                logger.error('💡 The command will automatically detect the existing PR and continue from where it left off.');
+                throw new Error(`Merge conflicts detected in PR #${pr.number}. Please resolve conflicts and re-run the command.`);
             } else {
-                const { stdout: commitTitle } = await run('git log -1 --pretty=%B');
-                pr = await createPullRequest(commitTitle, 'Automated release PR.', await getCurrentBranchName());
-                if (!pr) {
-                    throw new Error('Failed to create pull request.');
-                }
-                logger.info(`Pull request created: ${pr.html_url}`);
+                // Re-throw other merge errors
+                throw error;
             }
         }
-        logger.info(`Waiting for PR #${pr.number} checks to complete...`);
-        if (!isDryRun) {
-            var _runConfig_publish4, _runConfig_publish5, _runConfig_publish6;
-            // Configure timeout and user confirmation behavior
-            const timeout = ((_runConfig_publish4 = runConfig.publish) === null || _runConfig_publish4 === void 0 ? void 0 : _runConfig_publish4.checksTimeout) || 300000; // 5 minutes default
-            const senditMode = ((_runConfig_publish5 = runConfig.publish) === null || _runConfig_publish5 === void 0 ? void 0 : _runConfig_publish5.sendit) || false;
-            // sendit flag overrides skipUserConfirmation - if sendit is true, skip confirmation
-            const skipUserConfirmation = senditMode || ((_runConfig_publish6 = runConfig.publish) === null || _runConfig_publish6 === void 0 ? void 0 : _runConfig_publish6.skipUserConfirmation) || false;
-            await waitForPullRequestChecks(pr.number, {
-                timeout,
-                skipUserConfirmation
-            });
-        }
-        const mergeMethod = ((_runConfig_publish1 = runConfig.publish) === null || _runConfig_publish1 === void 0 ? void 0 : _runConfig_publish1.mergeMethod) || 'squash';
-        if (isDryRun) {
-            logger.info(`Would merge PR #${pr.number} using ${mergeMethod} method`);
+    }
+    // Switch to target branch and pull latest changes
+    logger.info(`Checking out target branch: ${targetBranch}...`);
+    try {
+        await runWithDryRunSupport(`git checkout ${targetBranch}`, isDryRun);
+        await runWithDryRunSupport(`git pull origin ${targetBranch}`, isDryRun);
+    } 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'))) {
+            logger.error(`❌ Failed to sync target branch '${targetBranch}' with remote.`);
+            logger.error('');
+            logger.error('📋 Recovery options:');
+            logger.error(`   1. Run 'kodrdriv publish --sync-target' to attempt automatic resolution`);
+            logger.error(`   2. Manually resolve conflicts:`);
+            logger.error(`      - git checkout ${targetBranch}`);
+            logger.error(`      - git pull origin ${targetBranch}`);
+            logger.error(`      - Resolve any conflicts and commit`);
+            logger.error(`      - Re-run your original publish command`);
+            logger.error('');
+            logger.error('💡 The publish process has been stopped to prevent data loss.');
+            throw new Error(`Target branch '${targetBranch}' sync failed. Use recovery options above to resolve.`);
         } else {
+            // Re-throw other errors
+            throw error;
+        }
+    }
+    // Now create and push the tag on the target branch
+    logger.info('Creating release tag...');
+    let tagName;
+    if (isDryRun) {
+        logger.info('Would read package.json version and create git tag');
+        tagName = 'v1.0.0'; // Mock version for dry run
+    } else {
+        const packageJsonContents = await storage.readFile('package.json', 'utf-8');
+        const { version } = safeJsonParse(packageJsonContents, 'package.json');
+        tagName = `v${version}`;
+        // Check if tag already exists locally
+        try {
+            // Validate tag name to prevent injection
+            if (!validateGitRef(tagName)) {
+                throw new Error(`Invalid tag name: ${tagName}`);
+            }
+            const { stdout } = await runSecure('git', [
+                'tag',
+                '-l',
+                tagName
+            ]);
+            if (stdout.trim() === tagName) {
+                logger.info(`Tag ${tagName} already exists locally, skipping tag creation`);
+            } else {
+                await runSecure('git', [
+                    'tag',
+                    tagName
+                ]);
+                logger.info(`Created local tag: ${tagName}`);
+            }
+        } catch (error) {
+            // If git tag -l fails, create the tag anyway
+            await runSecure('git', [
+                'tag',
+                tagName
+            ]);
+            logger.info(`Created local tag: ${tagName}`);
+        }
+        // Check if tag exists on remote before pushing
+        let tagWasPushed = false;
+        try {
+            const { stdout } = await runSecure('git', [
+                'ls-remote',
+                'origin',
+                `refs/tags/${tagName}`
+            ]);
+            if (stdout.trim()) {
+                logger.info(`Tag ${tagName} already exists on remote, skipping push`);
+            } else {
+                await runSecure('git', [
+                    'push',
+                    'origin',
+                    tagName
+                ]);
+                logger.info(`Pushed tag to remote: ${tagName}`);
+                tagWasPushed = true;
+            }
+        } catch (error) {
+            // If ls-remote fails, try to push anyway (might be a new remote)
             try {
-                await mergePullRequest(pr.number, mergeMethod);
-            } catch (error) {
-                // Check if this is a merge conflict error
-                if (error.message && (error.message.includes('not mergeable') || error.message.includes('Pull Request is not mergeable') || error.message.includes('merge conflict'))) {
-                    logger.error(`❌ Pull Request #${pr.number} has merge conflicts that need to be resolved.`);
-                    logger.error('');
-                    logger.error('📋 To resolve this issue:');
-                    logger.error(`   1. Visit the Pull Request: ${pr.html_url}`);
-                    logger.error('   2. Resolve the merge conflicts through GitHub\'s web interface or locally');
-                    logger.error('   3. Once conflicts are resolved, re-run the publish command');
-                    logger.error('');
-                    logger.error('💡 The command will automatically detect the existing PR and continue from where it left off.');
-                    throw new Error(`Merge conflicts detected in PR #${pr.number}. Please resolve conflicts and re-run the command.`);
+                await runSecure('git', [
+                    'push',
+                    'origin',
+                    tagName
+                ]);
+                logger.info(`Pushed tag to remote: ${tagName}`);
+                tagWasPushed = true;
+            } catch (pushError) {
+                if (pushError.message && pushError.message.includes('already exists')) {
+                    logger.info(`Tag ${tagName} already exists on remote, continuing...`);
                 } else {
-                    // Re-throw other merge errors
-                    throw error;
+                    throw pushError;
                 }
             }
         }
-        logger.info('Checking out main branch...');
-        await runWithDryRunSupport('git checkout main', isDryRun);
-        await runWithDryRunSupport('git pull origin main', isDryRun);
-        // Now create and push the tag on the main branch
-        logger.info('Creating release tag...');
-        let tagName;
-        if (isDryRun) {
-            logger.info('Would read package.json version and create git tag');
-            tagName = 'v1.0.0'; // Mock version for dry run
+        // If we just pushed a new tag, wait for GitHub to process it
+        if (tagWasPushed) {
+            logger.verbose('Waiting for GitHub to process the pushed tag...');
+            await new Promise((resolve)=>setTimeout(resolve, 5000)); // 5 second delay
+        }
+    }
+    logger.info('Creating GitHub release...');
+    if (isDryRun) {
+        var _runConfig_publish12;
+        logger.info('Would read package.json version and create GitHub release with retry logic');
+        const milestonesEnabled = !((_runConfig_publish12 = runConfig.publish) === null || _runConfig_publish12 === void 0 ? void 0 : _runConfig_publish12.noMilestones);
+        if (milestonesEnabled) {
+            logger.info('Would close milestone for released version');
         } else {
-            const packageJsonContents = await storage.readFile('package.json', 'utf-8');
-            const { version } = JSON.parse(packageJsonContents);
-            tagName = `v${version}`;
-            // Check if tag already exists locally
+            logger.info('Would skip milestone closure (--no-milestones)');
+        }
+    } else {
+        const outputDirectory = runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
+        const releaseNotesPath = getOutputPath(outputDirectory, 'RELEASE_NOTES.md');
+        const releaseTitlePath = getOutputPath(outputDirectory, 'RELEASE_TITLE.md');
+        const releaseNotesContent = await storage.readFile(releaseNotesPath, 'utf-8');
+        const releaseTitle = await storage.readFile(releaseTitlePath, 'utf-8');
+        // Create release with retry logic to handle GitHub tag processing delays
+        let retries = 3;
+        while(retries > 0){
             try {
-                const { stdout } = await run(`git tag -l ${tagName}`);
-                if (stdout.trim() === tagName) {
-                    logger.info(`Tag ${tagName} already exists locally, skipping tag creation`);
+                var _runConfig_publish13;
+                await createRelease(tagName, releaseTitle, releaseNotesContent);
+                logger.info(`GitHub release created successfully for tag: ${tagName}`);
+                // Close milestone for this version if enabled
+                const milestonesEnabled = !((_runConfig_publish13 = runConfig.publish) === null || _runConfig_publish13 === void 0 ? void 0 : _runConfig_publish13.noMilestones);
+                if (milestonesEnabled) {
+                    logger.info('🏁 Closing milestone for released version...');
+                    const version = tagName.replace(/^v/, ''); // Remove 'v' prefix if present
+                    await closeMilestoneForVersion(version);
                 } else {
-                    await run(`git tag ${tagName}`);
-                    logger.info(`Created local tag: ${tagName}`);
+                    logger.debug('Milestone integration disabled via --no-milestones');
                 }
+                break; // Success - exit retry loop
             } catch (error) {
-                // If git tag -l fails, create the tag anyway
-                await run(`git tag ${tagName}`);
-                logger.info(`Created local tag: ${tagName}`);
-            }
-            // Check if tag exists on remote before pushing
-            let tagWasPushed = false;
-            try {
-                const { stdout } = await run(`git ls-remote origin refs/tags/${tagName}`);
-                if (stdout.trim()) {
-                    logger.info(`Tag ${tagName} already exists on remote, skipping push`);
+                // Check if this is a tag-not-found error that we can retry
+                const isTagNotFoundError = error.message && (error.message.includes('not found') || error.message.includes('does not exist') || error.message.includes('Reference does not exist'));
+                if (isTagNotFoundError && retries > 1) {
+                    logger.verbose(`Tag ${tagName} not yet available on GitHub, retrying in 3 seconds... (${retries - 1} retries left)`);
+                    await new Promise((resolve)=>setTimeout(resolve, 3000));
+                    retries--;
+                } else if (isTagNotFoundError) {
+                    // Tag not found error and we're out of retries
+                    throw new Error(`Tag ${tagName} was not found on GitHub after ${3 - retries + 1} attempts. This may indicate a problem with tag creation or GitHub synchronization.`);
                 } else {
-                    await run(`git push origin ${tagName}`);
-                    logger.info(`Pushed tag to remote: ${tagName}`);
-                    tagWasPushed = true;
-                }
-            } catch (error) {
-                // If ls-remote fails, try to push anyway (might be a new remote)
-                try {
-                    await run(`git push origin ${tagName}`);
-                    logger.info(`Pushed tag to remote: ${tagName}`);
-                    tagWasPushed = true;
-                } catch (pushError) {
-                    if (pushError.message && pushError.message.includes('already exists')) {
-                        logger.info(`Tag ${tagName} already exists on remote, continuing...`);
-                    } else {
-                        throw pushError;
-                    }
+                    // Not a tag-not-found error - re-throw the original error
+                    throw error;
                 }
             }
-            // If we just pushed a new tag, wait for GitHub to process it
-            if (tagWasPushed) {
-                logger.verbose('Waiting for GitHub to process the pushed tag...');
-                await new Promise((resolve)=>setTimeout(resolve, 5000)); // 5 second delay
-            }
         }
-        logger.info('Creating GitHub release...');
+    }
+    // Wait for release workflows to complete (if enabled)
+    const waitForWorkflows = ((_runConfig_publish3 = runConfig.publish) === null || _runConfig_publish3 === void 0 ? void 0 : _runConfig_publish3.waitForReleaseWorkflows) !== false; // default to true
+    if (waitForWorkflows) {
+        logger.info('Waiting for release workflows...');
         if (isDryRun) {
-            logger.info('Would read package.json version and create GitHub release with retry logic');
+            logger.info('Would monitor GitHub Actions workflows triggered by release');
         } else {
-            const outputDirectory = runConfig.outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
-            const releaseNotesPath = getOutputPath(outputDirectory, 'RELEASE_NOTES.md');
-            const releaseTitlePath = getOutputPath(outputDirectory, 'RELEASE_TITLE.md');
-            const releaseNotesContent = await storage.readFile(releaseNotesPath, 'utf-8');
-            const releaseTitle = await storage.readFile(releaseTitlePath, 'utf-8');
-            // Create release with retry logic to handle GitHub tag processing delays
-            let retries = 3;
-            while(retries > 0){
+            var _runConfig_publish14, _runConfig_publish15, _runConfig_publish16, _runConfig_publish17;
+            const workflowTimeout = ((_runConfig_publish14 = runConfig.publish) === null || _runConfig_publish14 === void 0 ? void 0 : _runConfig_publish14.releaseWorkflowsTimeout) || 600000; // 10 minutes default
+            const senditMode = ((_runConfig_publish15 = runConfig.publish) === null || _runConfig_publish15 === void 0 ? void 0 : _runConfig_publish15.sendit) || false;
+            const skipUserConfirmation = senditMode || ((_runConfig_publish16 = runConfig.publish) === null || _runConfig_publish16 === void 0 ? void 0 : _runConfig_publish16.skipUserConfirmation) || false;
+            // Get workflow names - either from config or auto-detect
+            let workflowNames = (_runConfig_publish17 = runConfig.publish) === null || _runConfig_publish17 === void 0 ? void 0 : _runConfig_publish17.releaseWorkflowNames;
+            if (!workflowNames || workflowNames.length === 0) {
+                logger.info('No specific workflow names configured, auto-detecting workflows triggered by release events...');
                 try {
-                    await createRelease(tagName, releaseTitle, releaseNotesContent);
-                    logger.info(`GitHub release created successfully for tag: ${tagName}`);
-                    break; // Success - exit retry loop
-                } catch (error) {
-                    // Check if this is a tag-not-found error that we can retry
-                    const isTagNotFoundError = error.message && (error.message.includes('not found') || error.message.includes('does not exist') || error.message.includes('Reference does not exist'));
-                    if (isTagNotFoundError && retries > 1) {
-                        logger.verbose(`Tag ${tagName} not yet available on GitHub, retrying in 3 seconds... (${retries - 1} retries left)`);
-                        await new Promise((resolve)=>setTimeout(resolve, 3000));
-                        retries--;
-                    } else if (isTagNotFoundError) {
-                        // Tag not found error and we're out of retries
-                        throw new Error(`Tag ${tagName} was not found on GitHub after ${3 - retries + 1} attempts. This may indicate a problem with tag creation or GitHub synchronization.`);
+                    workflowNames = await getWorkflowsTriggeredByRelease();
+                    if (workflowNames.length === 0) {
+                        logger.info('No workflows found that are triggered by release events.');
                     } else {
-                        // Not a tag-not-found error - re-throw the original error
-                        throw error;
-                    }
-                }
-            }
-        }
-        // Wait for release workflows to complete (if enabled)
-        const waitForWorkflows = ((_runConfig_publish2 = runConfig.publish) === null || _runConfig_publish2 === void 0 ? void 0 : _runConfig_publish2.waitForReleaseWorkflows) !== false; // default to true
-        if (waitForWorkflows) {
-            logger.info('Waiting for release workflows...');
-            if (isDryRun) {
-                logger.info('Would monitor GitHub Actions workflows triggered by release');
-            } else {
-                var _runConfig_publish7, _runConfig_publish8, _runConfig_publish9, _runConfig_publish10;
-                const workflowTimeout = ((_runConfig_publish7 = runConfig.publish) === null || _runConfig_publish7 === void 0 ? void 0 : _runConfig_publish7.releaseWorkflowsTimeout) || 600000; // 10 minutes default
-                const senditMode = ((_runConfig_publish8 = runConfig.publish) === null || _runConfig_publish8 === void 0 ? void 0 : _runConfig_publish8.sendit) || false;
-                const skipUserConfirmation = senditMode || ((_runConfig_publish9 = runConfig.publish) === null || _runConfig_publish9 === void 0 ? void 0 : _runConfig_publish9.skipUserConfirmation) || false;
-                // Get workflow names - either from config or auto-detect
-                let workflowNames = (_runConfig_publish10 = runConfig.publish) === null || _runConfig_publish10 === void 0 ? void 0 : _runConfig_publish10.releaseWorkflowNames;
-                if (!workflowNames || workflowNames.length === 0) {
-                    logger.info('No specific workflow names configured, auto-detecting workflows triggered by release events...');
-                    try {
-                        workflowNames = await getWorkflowsTriggeredByRelease();
-                        if (workflowNames.length === 0) {
-                            logger.info('No workflows found that are triggered by release events.');
-                        } else {
-                            logger.info(`Auto-detected release workflows: ${workflowNames.join(', ')}`);
-                        }
-                    } catch (error) {
-                        logger.warn(`Failed to auto-detect release workflows: ${error.message}`);
-                        workflowNames = undefined; // Fall back to monitoring all workflows
+                        logger.info(`Auto-detected release workflows: ${workflowNames.join(', ')}`);
                     }
+                } catch (error) {
+                    logger.warn(`Failed to auto-detect release workflows: ${error.message}`);
+                    workflowNames = undefined; // Fall back to monitoring all workflows
                 }
-                await waitForReleaseWorkflows(tagName, {
-                    timeout: workflowTimeout,
-                    workflowNames,
-                    skipUserConfirmation
-                });
-            }
-        } else {
-            logger.verbose('Skipping waiting for release workflows (disabled in config).');
-        }
-        logger.info('Creating new release branch...');
-        if (isDryRun) {
-            logger.info('Would create next release branch (e.g., release/1.0.1) and push to origin');
-        } else {
-            const packageJsonContents = await storage.readFile('package.json', 'utf-8');
-            const { version } = JSON.parse(packageJsonContents);
-            const nextVersion = incrementPatchVersion(version);
-            const newBranchName = `release/${nextVersion}`;
-            // Check if branch already exists locally
-            let branchExists = false;
-            try {
-                await run(`git show-ref --verify --quiet refs/heads/${newBranchName}`);
-                branchExists = true;
-            } catch  {
-                // Branch doesn't exist locally
-                branchExists = false;
-            }
-            if (branchExists) {
-                // Branch exists, switch to it
-                await run(`git checkout ${newBranchName}`);
-                logger.info(`Switched to existing branch ${newBranchName}`);
-            } else {
-                // Branch doesn't exist, create it
-                await run(`git checkout -b ${newBranchName}`);
-                logger.info(`Created new branch ${newBranchName}`);
-            }
-            // Check if branch exists on remote before pushing
-            let remoteExists = false;
-            try {
-                const { stdout } = await run(`git ls-remote origin refs/heads/${newBranchName}`);
-                remoteExists = stdout.trim() !== '';
-            } catch  {
-                // Assume remote doesn't exist if ls-remote fails
-                remoteExists = false;
-            }
-            if (remoteExists) {
-                logger.info(`Branch ${newBranchName} already exists on remote, skipping push`);
-            } else {
-                await run(`git push -u origin ${newBranchName}`);
-                logger.info(`Branch ${newBranchName} pushed to origin.`);
             }
+            await waitForReleaseWorkflows(tagName, {
+                timeout: workflowTimeout,
+                workflowNames,
+                skipUserConfirmation
+            });
         }
-        logger.info('Preparation complete.');
-        publishCompleted = true; // Mark as completed only if we reach this point
-    } finally{
-        var _runConfig_publish11;
-        // Link packages if linking is enabled, regardless of whether we unlinked them
-        const shouldLink = ((_runConfig_publish11 = runConfig.publish) === null || _runConfig_publish11 === void 0 ? void 0 : _runConfig_publish11.linkWorkspacePackages) !== false; // default to true
-        if (shouldLink) {
-            logger.verbose('Ensuring linked packages are properly set up...');
-            await execute$4(runConfig);
-        } else {
-            logger.verbose('Skipping link packages (disabled in config).');
-        }
+    } 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.');
 };
 
 export { execute };