@eldrforge/kodrdriv 0.0.51 → 0.1.0

package/dist/commands/publish.js

@@ -1,20 +1,18 @@
-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 { 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';
 
 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 +55,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 +94,20 @@ 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 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 +138,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([
@@ -156,342 +155,322 @@ const runPrechecks = async (runConfig)=>{
     logger.info('All prechecks passed.');
 };
 const execute = async (runConfig)=>{
+    var _runConfig_publish, _runConfig_publish1, _runConfig_publish2;
     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;
     // 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;
-        } else {
-            logger.verbose('Skipping unlink workspace packages (disabled in config).');
-        }
-        let pr = null;
+    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_publish3, _runConfig_publish4, _runConfig_publish5;
+        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 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}`);
+            logger.info('Would determine target version and update package.json');
+            newVersion = '1.0.0'; // Mock version for dry run
         } 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);
-            } else {
-                logger.verbose('No dependency update patterns specified, updating all dependencies');
-                await runWithDryRunSupport('npm update', isDryRun);
+            var _runConfig_publish6, _runConfig_publish7;
+            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_publish6 = runConfig.publish) === null || _runConfig_publish6 === void 0 ? void 0 : _runConfig_publish6.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.`);
             }
-            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.');
+            // Interactive confirmation if --interactive flag is set
+            if ((_runConfig_publish7 = runConfig.publish) === null || _runConfig_publish7 === void 0 ? void 0 : _runConfig_publish7.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.`);
                 }
-            }
-            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}`);
-            }
-            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}.`);
-            }
-            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(`Pull request created: ${pr.html_url}`);
+                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}`);
         }
-        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`);
+        // 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_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);
         } else {
-            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.`);
-                } else {
-                    // Re-throw other merge errors
-                    throw error;
-                }
-            }
+            logger.verbose('No dependency update patterns specified, updating all dependencies');
+            await runWithDryRunSupport('npm update', isDryRun);
         }
-        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;
+        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.info('Would read package.json version and create git tag');
-            tagName = 'v1.0.0'; // Mock version for dry run
+            logger.verbose('Assuming staged changes exist for demo purposes');
+            logger.verbose('Would create commit...');
+            await execute$1(runConfig);
         } else {
-            const packageJsonContents = await storage.readFile('package.json', 'utf-8');
-            const { version } = JSON.parse(packageJsonContents);
-            tagName = `v${version}`;
-            // Check if tag already exists locally
-            try {
-                const { stdout } = await run(`git tag -l ${tagName}`);
-                if (stdout.trim() === tagName) {
-                    logger.info(`Tag ${tagName} already exists locally, skipping tag creation`);
-                } else {
-                    await run(`git tag ${tagName}`);
-                    logger.info(`Created local tag: ${tagName}`);
-                }
-            } catch (error) {
-                // If git tag -l fails, create the tag anyway
-                await run(`git tag ${tagName}`);
-                logger.info(`Created local tag: ${tagName}`);
+            if (await hasStagedChanges()) {
+                logger.verbose('Staged changes found, creating commit...');
+                await execute$1(runConfig);
+            } else {
+                logger.verbose('No changes to commit, skipping commit.');
             }
-            // 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`);
-                } 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;
-                    }
+        }
+        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_publish4 = runConfig.publish) === null || _runConfig_publish4 === void 0 ? void 0 : _runConfig_publish4.from) || ((_runConfig_publish5 = runConfig.publish) === null || _runConfig_publish5 === void 0 ? void 0 : _runConfig_publish5.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}`);
             }
-            // 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
+            if (runConfig.publish.interactive) {
+                logger.verbose('Interactive mode enabled for release notes generation');
             }
         }
-        logger.info('Creating GitHub release...');
+        const releaseSummary = await execute$2(releaseConfig);
         if (isDryRun) {
-            logger.info('Would read package.json version and create GitHub release with retry logic');
+            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');
-            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 {
-                    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.`);
-                    } else {
-                        // Not a tag-not-found error - re-throw the original error
-                        throw error;
-                    }
-                }
+            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(`Pull request created: ${pr.html_url}`);
         }
-        // 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');
+    }
+    logger.info(`Waiting for PR #${pr.number} checks to complete...`);
+    if (!isDryRun) {
+        var _runConfig_publish8, _runConfig_publish9, _runConfig_publish10;
+        // Configure timeout and user confirmation behavior
+        const timeout = ((_runConfig_publish8 = runConfig.publish) === null || _runConfig_publish8 === void 0 ? void 0 : _runConfig_publish8.checksTimeout) || 300000; // 5 minutes default
+        const senditMode = ((_runConfig_publish9 = runConfig.publish) === null || _runConfig_publish9 === void 0 ? void 0 : _runConfig_publish9.sendit) || false;
+        // sendit flag overrides skipUserConfirmation - if sendit is true, skip confirmation
+        const skipUserConfirmation = senditMode || ((_runConfig_publish10 = runConfig.publish) === null || _runConfig_publish10 === void 0 ? void 0 : _runConfig_publish10.skipUserConfirmation) || false;
+        await waitForPullRequestChecks(pr.number, {
+            timeout,
+            skipUserConfirmation
+        });
+    }
+    const mergeMethod = ((_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.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 {
-                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
-                    }
-                }
-                await waitForReleaseWorkflows(tagName, {
-                    timeout: workflowTimeout,
-                    workflowNames,
-                    skipUserConfirmation
-                });
+                // Re-throw other merge errors
+                throw error;
             }
-        } 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;
+    }
+    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
+    } else {
+        const packageJsonContents = await storage.readFile('package.json', 'utf-8');
+        const { version } = JSON.parse(packageJsonContents);
+        tagName = `v${version}`;
+        // Check if tag already exists locally
+        try {
+            const { stdout } = await run(`git tag -l ${tagName}`);
+            if (stdout.trim() === tagName) {
+                logger.info(`Tag ${tagName} already exists locally, skipping tag creation`);
+            } else {
+                await run(`git tag ${tagName}`);
+                logger.info(`Created local tag: ${tagName}`);
             }
-            if (branchExists) {
-                // Branch exists, switch to it
-                await run(`git checkout ${newBranchName}`);
-                logger.info(`Switched to existing branch ${newBranchName}`);
+        } 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`);
             } else {
-                // Branch doesn't exist, create it
-                await run(`git checkout -b ${newBranchName}`);
-                logger.info(`Created new branch ${newBranchName}`);
+                await run(`git push origin ${tagName}`);
+                logger.info(`Pushed tag to remote: ${tagName}`);
+                tagWasPushed = true;
             }
-            // Check if branch exists on remote before pushing
-            let remoteExists = false;
+        } catch (error) {
+            // If ls-remote fails, try to push anyway (might be a new remote)
             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;
+                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;
+                }
             }
-            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.`);
+        }
+        // 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) {
+        logger.info('Would read package.json version and create GitHub release with retry logic');
+    } 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 {
+                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.`);
+                } else {
+                    // Not a tag-not-found error - re-throw the original error
+                    throw error;
+                }
             }
         }
-        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);
+    }
+    // Wait for release workflows to complete (if enabled)
+    const waitForWorkflows = ((_runConfig_publish1 = runConfig.publish) === null || _runConfig_publish1 === void 0 ? void 0 : _runConfig_publish1.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 {
-            logger.verbose('Skipping link packages (disabled in config).');
+            var _runConfig_publish11, _runConfig_publish12, _runConfig_publish13, _runConfig_publish14;
+            const workflowTimeout = ((_runConfig_publish11 = runConfig.publish) === null || _runConfig_publish11 === void 0 ? void 0 : _runConfig_publish11.releaseWorkflowsTimeout) || 600000; // 10 minutes default
+            const senditMode = ((_runConfig_publish12 = runConfig.publish) === null || _runConfig_publish12 === void 0 ? void 0 : _runConfig_publish12.sendit) || false;
+            const skipUserConfirmation = senditMode || ((_runConfig_publish13 = runConfig.publish) === null || _runConfig_publish13 === void 0 ? void 0 : _runConfig_publish13.skipUserConfirmation) || false;
+            // Get workflow names - either from config or auto-detect
+            let workflowNames = (_runConfig_publish14 = runConfig.publish) === null || _runConfig_publish14 === void 0 ? void 0 : _runConfig_publish14.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
+                }
+            }
+            await waitForReleaseWorkflows(tagName, {
+                timeout: workflowTimeout,
+                workflowNames,
+                skipUserConfirmation
+            });
         }
+    } else {
+        logger.verbose('Skipping waiting for release workflows (disabled in config).');
     }
+    // Switch to target branch
+    const targetBranch = ((_runConfig_publish2 = runConfig.publish) === null || _runConfig_publish2 === void 0 ? void 0 : _runConfig_publish2.targetBranch) || 'main';
+    logger.info(`Switching to target branch: ${targetBranch}`);
+    await runWithDryRunSupport(`git checkout ${targetBranch}`, isDryRun);
+    logger.info('Publish process complete.');
 };
 
 export { execute };