claude-git-hooks 2.21.0 → 2.30.2

package/lib/commands/create-pr.js

@@ -23,6 +23,21 @@ import { getBranchPushStatus, pushBranch } from '../utils/git-operations.js';
 import logger from '../utils/logger.js';
 import { error, checkGitRepo } from './helpers.js';
 
+/**
+ * Detect expected merge strategy from branch naming conventions
+ * @param {string} sourceBranch - Source (head) branch name
+ * @param {string} targetBranch - Target (base) branch name
+ * @returns {'squash'|'merge-commit'|'unknown'}
+ */
+function detectMergeStrategy(sourceBranch, targetBranch) {
+    if (targetBranch === 'main') return 'merge-commit';
+    if (sourceBranch.startsWith('feature/')) return 'squash';
+    if (sourceBranch.startsWith('release-fix/')) return 'squash';
+    if (sourceBranch.startsWith('release-candidate/')) return 'merge-commit';
+    if (sourceBranch.startsWith('hotfix/')) return 'merge-commit';
+    return 'unknown';
+}
+
 /**
  * Create PR command (v2.5.0+ - Octokit-based)
  * @param {Array<string>} args - Command arguments
@@ -48,8 +63,9 @@ export async function runCreatePr(args) {
 
         // Import GitHub API module
         logger.debug('create-pr', 'Importing GitHub API modules');
-        const { createPullRequest, validateToken, findExistingPR } =
-            await import('../utils/github-api.js');
+        const { createPullRequest, validateToken, findExistingPR } = await import(
+            '../utils/github-api.js'
+        );
         const { parseGitHubRepo } = await import('../utils/github-client.js');
 
         showInfo('🚀 Creating Pull Request...');
@@ -552,6 +568,39 @@ export async function runCreatePr(args) {
         }
         logger.debug('create-pr', 'Labels determined', { labels, preset: config.preset });
 
+        // Step 9.5: Detect merge strategy
+        logger.debug('create-pr', 'Step 9.5: Detecting merge strategy', {
+            sourceBranch: currentBranch,
+            targetBranch: baseBranch
+        });
+        let mergeStrategy = detectMergeStrategy(currentBranch, baseBranch);
+
+        if (mergeStrategy === 'unknown') {
+            showWarning('Unknown branch pattern — cannot auto-detect merge strategy');
+            console.log('');
+            const strategyChoice = await promptMenu(
+                'Select merge strategy:',
+                [
+                    { key: 's', label: 'Squash merge' },
+                    { key: 'm', label: 'Merge commit' },
+                    { key: 'k', label: 'Skip (no strategy label)' }
+                ],
+                'k'
+            );
+            if (strategyChoice === 's') mergeStrategy = 'squash';
+            else if (strategyChoice === 'm') mergeStrategy = 'merge-commit';
+        }
+
+        if (mergeStrategy !== 'unknown') {
+            labels.push(`merge-strategy:${mergeStrategy}`);
+            logger.debug('create-pr', 'Merge strategy label added', { mergeStrategy });
+        }
+
+        let finalBody = prBody;
+        if (mergeStrategy === 'merge-commit') {
+            finalBody = `> ⚠️ This PR must be merged with **merge commit** (not squash)\n\n${prBody}`;
+        }
+
         // Step 10: Get reviewers from CODEOWNERS and config
         logger.debug('create-pr', 'Step 10: Getting reviewers from CODEOWNERS and config');
         const reviewers = await getReviewersForFiles(filesArray, config.github?.pr);
@@ -563,7 +612,7 @@ export async function runCreatePr(args) {
         // Step 11: Show PR preview
         const prData = {
             title: prTitle,
-            body: prBody,
+            body: finalBody,
             head: currentBranch,
             base: baseBranch,
             labels,
@@ -572,6 +621,16 @@ export async function runCreatePr(args) {
 
         showPRPreview(prData);
 
+        let strategyLabel;
+        if (mergeStrategy === 'squash') {
+            strategyLabel = 'SQUASH MERGE';
+        } else if (mergeStrategy === 'merge-commit') {
+            strategyLabel = 'MERGE COMMIT';
+        } else {
+            strategyLabel = 'UNKNOWN';
+        }
+        showInfo(`Merge strategy: ${strategyLabel} (${currentBranch} → ${baseBranch})`);
+
         // Step 12: Prompt for confirmation
         const action = await promptMenu(
             'What would you like to do?',

package/lib/commands/create-release.js

@@ -0,0 +1,600 @@
+/**
+ * File: create-release.js
+ * Purpose: create-release command — release-candidate branch creation from develop
+ *
+ * Workflow:
+ * 1. Validate preconditions (clean tree, on develop, up-to-date, no existing RC)
+ * 2. Discover version files — abort on mismatch
+ * 3. Calculate next version
+ * 4. [dry-run] Preview + return
+ * 5. Confirm with user
+ * 6. Create RC branch from develop
+ * 7. Bump version files + commit (--no-verify)
+ * 8. [optional] Generate CHANGELOG
+ * 9. Create Git tag (skip if already exists)
+ * 10. Push RC branch (unless --skip-push)
+ * 11. Deploy to shadow (unless --no-shadow or --skip-push)
+ * 12. Return to RC branch
+ * 13. Display summary
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import {
+    discoverVersionFiles,
+    incrementVersion,
+    updateVersionFiles
+} from '../utils/version-manager.js';
+import { createTag, tagExists, formatTagName } from '../utils/git-tag-manager.js';
+import {
+    generateChangelogEntry,
+    updateChangelogFile,
+    selectChangelogFile
+} from '../utils/changelog-generator.js';
+import {
+    getRepoRoot,
+    getCurrentBranch,
+    verifyRemoteExists,
+    getRemoteName,
+    fetchRemote,
+    getDivergence,
+    getRemoteBranches,
+    isWorkingDirectoryClean,
+    checkoutBranch,
+    pushBranch,
+    stageFiles,
+    createCommit
+} from '../utils/git-operations.js';
+import { runShadow } from './shadow.js';
+import { getConfig } from '../config.js';
+import {
+    showInfo,
+    showSuccess,
+    showError,
+    showWarning,
+    promptConfirmation
+} from '../utils/interactive-ui.js';
+import logger from '../utils/logger.js';
+import { colors, error, checkGitRepo } from './helpers.js';
+
+/** Source branch for RC creation */
+const SOURCE_BRANCH = 'develop';
+
+/** RC branch prefix */
+const RC_PREFIX = 'release-candidate';
+
+/**
+ * Parses command line arguments
+ *
+ * @param {string[]} args - CLI arguments
+ * @returns {Object} Parsed options
+ */
+function parseArguments(args) {
+    const parsed = {
+        bumpType: null,
+        noShadow: false,
+        dryRun: false,
+        skipPush: false,
+        updateChangelog: false
+    };
+
+    if (args.length === 0) return parsed;
+
+    let i = 0;
+    const firstArg = args[0].toLowerCase();
+    if (['major', 'minor', 'patch'].includes(firstArg)) {
+        parsed.bumpType = firstArg;
+        i = 1;
+    }
+
+    for (; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--no-shadow') parsed.noShadow = true;
+        else if (arg === '--dry-run') parsed.dryRun = true;
+        else if (arg === '--skip-push') parsed.skipPush = true;
+        else if (arg === '--update-changelog') parsed.updateChangelog = true;
+    }
+
+    return parsed;
+}
+
+/**
+ * Validates preconditions before creating a release-candidate
+ * Checks: git repo, clean tree, on develop, develop up-to-date, develop not behind main, no existing RC
+ *
+ * @returns {Promise<{ valid: boolean, errors: Array<{ type: string, message: string, fix?: string[] }> }>}
+ */
+async function validatePreconditions() {
+    const errors = [];
+
+    if (!checkGitRepo()) {
+        errors.push({ type: 'fatal', message: 'Not a git repository' });
+        return { valid: false, errors };
+    }
+
+    if (!isWorkingDirectoryClean()) {
+        errors.push({
+            type: 'fatal',
+            message: 'Working directory has uncommitted changes',
+            fix: [
+                'Commit your changes:  git add . && git commit -m "..."',
+                'Or stash them:        git stash'
+            ]
+        });
+    }
+
+    const currentBranch = getCurrentBranch();
+    if (currentBranch !== SOURCE_BRANCH) {
+        errors.push({
+            type: 'fatal',
+            message: `Must be on '${SOURCE_BRANCH}' branch (currently on '${currentBranch}')`,
+            fix: [`git checkout ${SOURCE_BRANCH}`]
+        });
+        // Return early: divergence checks require being on develop
+        return { valid: false, errors };
+    }
+
+    try {
+        fetchRemote();
+    } catch (e) {
+        errors.push({
+            type: 'warn',
+            message: `Could not fetch from remote: ${e.message} — results may be stale`
+        });
+    }
+
+    try {
+        const devSync = getDivergence(SOURCE_BRANCH, `origin/${SOURCE_BRANCH}`);
+        if (devSync.behind > 0) {
+            errors.push({
+                type: 'fatal',
+                message: `Local '${SOURCE_BRANCH}' is ${devSync.behind} commit(s) behind remote`,
+                fix: [`git pull origin ${SOURCE_BRANCH}`]
+            });
+        }
+    } catch (e) {
+        errors.push({
+            type: 'warn',
+            message: `Could not check if ${SOURCE_BRANCH} is up-to-date with remote: ${e.message}`
+        });
+    }
+
+    try {
+        const mainSync = getDivergence(`origin/${SOURCE_BRANCH}`, 'origin/main');
+        if (mainSync.behind > 0) {
+            errors.push({
+                type: 'fatal',
+                message: `'${SOURCE_BRANCH}' is missing ${mainSync.behind} commit(s) from 'main' — a back-merge is required`,
+                fix: [
+                    'Merge main into develop first:',
+                    `  git checkout ${SOURCE_BRANCH} && git merge origin/main`,
+                    '  or: claude-hooks back-merge  (when available)'
+                ]
+            });
+        }
+    } catch (e) {
+        errors.push({
+            type: 'warn',
+            message: `Could not verify ${SOURCE_BRANCH} vs main sync: ${e.message}`
+        });
+    }
+
+    const remoteBranches = getRemoteBranches();
+    const existingRCs = remoteBranches.filter((b) => b.startsWith(`${RC_PREFIX}/`));
+    if (existingRCs.length > 0) {
+        errors.push({
+            type: 'fatal',
+            message: `Existing release-candidate branch found: ${existingRCs.join(', ')}`,
+            fix: [
+                'Close the active release-candidate first:',
+                '  claude-hooks close-release  (when available)',
+                `  or delete manually: git push origin --delete ${existingRCs[0]}`
+            ]
+        });
+    }
+
+    const remoteName = getRemoteName();
+    if (!verifyRemoteExists(remoteName)) {
+        errors.push({
+            type: 'fatal',
+            message: `Remote '${remoteName}' does not exist`,
+            fix: ['git remote add origin <url>']
+        });
+    }
+
+    const fatalErrors = errors.filter((e) => e.type === 'fatal');
+    return { valid: fatalErrors.length === 0, errors };
+}
+
+/**
+ * Displays a dry-run preview of what would be executed
+ *
+ * @param {Object} info - Preview info
+ */
+function showDryRunPreview({ bumpType, currentVersion, nextVersion, rcBranch, options }) {
+    const tagName = formatTagName(nextVersion);
+
+    console.log('');
+    console.log(`${colors.yellow}═════════════════════════════════════════════════${colors.reset}`);
+    console.log(`${colors.yellow}           DRY RUN — No changes will be made     ${colors.reset}`);
+    console.log(`${colors.yellow}═════════════════════════════════════════════════${colors.reset}`);
+    console.log('');
+    console.log(`${colors.blue}Operation:${colors.reset}      Bump ${bumpType}`);
+    console.log(`${colors.blue}Current version:${colors.reset} ${currentVersion}`);
+    console.log(`${colors.green}New version:${colors.reset}     ${nextVersion}`);
+    console.log(`${colors.blue}Branch:${colors.reset}          ${rcBranch}`);
+    console.log(`${colors.blue}Tag:${colors.reset}             ${tagName}`);
+    console.log(
+        `${colors.blue}Push:${colors.reset}            ${options.skipPush ? 'skipped (--skip-push)' : 'yes → origin'}`
+    );
+    console.log(
+        `${colors.blue}Shadow sync:${colors.reset}     ${
+            options.noShadow
+                ? 'skipped (--no-shadow)'
+                : options.skipPush
+                    ? 'skipped (branch not pushed)'
+                    : 'yes'
+        }`
+    );
+    if (options.updateChangelog) {
+        console.log(`${colors.blue}CHANGELOG:${colors.reset}       will be generated`);
+    }
+    console.log('');
+    console.log(`${colors.yellow}Run without --dry-run to apply these changes${colors.reset}`);
+    console.log('');
+}
+
+/**
+ * Restores version files from a snapshot map (rollback)
+ *
+ * @param {Map<string, string>} snapshot - Map of filePath → original content
+ */
+function restoreSnapshot(snapshot) {
+    snapshot.forEach((content, filePath) => {
+        try {
+            fs.writeFileSync(filePath, content, 'utf8');
+        } catch (e) {
+            logger.error('create-release', 'Rollback failed during snapshot restoration', {
+                path: filePath,
+                operation: 'restoreSnapshot',
+                error: e.message
+            });
+        }
+    });
+}
+
+/**
+ * create-release command
+ * Creates a release-candidate branch from develop, bumps version, and deploys to shadow.
+ *
+ * @param {string[]} args - CLI arguments
+ */
+export async function runCreateRelease(args) {
+    logger.debug('create-release', 'Starting create-release command', { args });
+
+    const options = parseArguments(args);
+
+    if (!options.bumpType) {
+        error('Usage: claude-hooks create-release <major|minor|patch> [options]');
+        console.log('');
+        console.log('Options:');
+        console.log('  --no-shadow          Skip shadow deployment');
+        console.log('  --dry-run            Preview changes without executing');
+        console.log('  --skip-push          Create branch locally only (also skips shadow)');
+        console.log('  --update-changelog   Generate CHANGELOG entry');
+        console.log('');
+        console.log('Examples:');
+        console.log('  claude-hooks create-release minor');
+        console.log('  claude-hooks create-release minor --no-shadow');
+        console.log('  claude-hooks create-release minor --dry-run');
+        console.log('  claude-hooks create-release patch --update-changelog');
+        return;
+    }
+
+    showInfo(`🚀 Creating release-candidate (${options.bumpType})...`);
+    console.log('');
+
+    // Step 1: Validate preconditions
+    logger.debug('create-release', 'Step 1: Validating preconditions');
+    const { valid, errors } = await validatePreconditions();
+
+    errors.filter((e) => e.type === 'warn').forEach((e) => showWarning(e.message));
+
+    if (!valid) {
+        const fatalErrors = errors.filter((e) => e.type === 'fatal');
+        showError('Precondition check failed:');
+        console.log('');
+        fatalErrors.forEach((e) => {
+            console.log(`  ❌ ${e.message}`);
+            if (e.fix) {
+                e.fix.forEach((line) => console.log(`     ${line}`));
+            }
+            console.log('');
+        });
+        process.exit(1);
+    }
+
+    showSuccess('Preconditions validated');
+    console.log('');
+
+    // Step 2: Discover version files
+    logger.debug('create-release', 'Step 2: Discovering version files');
+    const discovery = discoverVersionFiles();
+
+    if (discovery.files.length === 0) {
+        showError('No version files found');
+        console.log('');
+        console.log('This command requires at least one version file (package.json, pom.xml, etc.)');
+        process.exit(1);
+    }
+
+    if (discovery.mismatch) {
+        showError('Version mismatch detected — cannot proceed automatically');
+        console.log('');
+        console.log(`  ${'File'.padEnd(40)} ${'Type'.padEnd(18)} Version`);
+        console.log(`  ${'-'.repeat(40)} ${'-'.repeat(18)} -------`);
+        discovery.files.forEach((f) => {
+            const marker = f.version !== discovery.resolvedVersion ? '⚠️ ' : '   ';
+            console.log(
+                `  ${marker}${f.relativePath.padEnd(37)} ${f.projectLabel.padEnd(18)} ${f.version || 'N/A'}`
+            );
+        });
+        console.log('');
+        console.log('Fix: align all version files to the same version, then re-run.');
+        console.log('  1. Edit version files manually to match');
+        console.log(
+            '  2. Commit:  git add . && git commit -m "chore(version): align versions"'
+        );
+        console.log(`  3. Re-run:  claude-hooks create-release ${options.bumpType}`);
+        process.exit(1);
+    }
+
+    const currentVersion = discovery.resolvedVersion;
+    if (!currentVersion) {
+        showError('Could not determine current version from discovered files');
+        process.exit(1);
+    }
+
+    // Step 3: Calculate next version
+    const nextVersion = incrementVersion(currentVersion, options.bumpType);
+    const rcBranch = `${RC_PREFIX}/V${nextVersion}`;
+    const tagName = formatTagName(nextVersion);
+
+    showInfo(`Current version: ${currentVersion}`);
+    showSuccess(`Next version:    ${nextVersion}`);
+    showInfo(`Branch:          ${rcBranch}`);
+    console.log('');
+
+    // Step 4: Dry-run
+    if (options.dryRun) {
+        showDryRunPreview({ bumpType: options.bumpType, currentVersion, nextVersion, rcBranch, options });
+        return;
+    }
+
+    // Step 5: Confirm with user
+    const confirmed = await promptConfirmation(
+        `Create ${rcBranch} and bump version to ${nextVersion}?`,
+        true
+    );
+    if (!confirmed) {
+        showInfo('Release creation cancelled');
+        process.exit(0);
+    }
+
+    console.log('');
+
+    try {
+        const config = await getConfig();
+        const selectedFiles = discovery.files.filter((f) => f.selected);
+
+        // Step 6: Create RC branch from develop
+        logger.debug('create-release', 'Step 6: Creating RC branch', { rcBranch });
+        showInfo(`Creating branch ${rcBranch} from ${SOURCE_BRANCH}...`);
+        checkoutBranch(rcBranch, { create: true, startPoint: SOURCE_BRANCH });
+        showSuccess(`✓ Branch created: ${rcBranch}`);
+        console.log('');
+
+        // Snapshot for rollback
+        const snapshot = new Map();
+        selectedFiles.forEach((file) => {
+            try {
+                snapshot.set(file.path, fs.readFileSync(file.path, 'utf8'));
+            } catch (e) {
+                logger.error('create-release', 'Failed to snapshot file', {
+                    path: file.path,
+                    error: e.message
+                });
+            }
+        });
+
+        // Step 7: Bump version files
+        logger.debug('create-release', 'Step 7: Bumping version files');
+        showInfo('Updating version files...');
+        try {
+            updateVersionFiles(selectedFiles, nextVersion);
+            selectedFiles.forEach((f) =>
+                showSuccess(`✓ Updated ${f.relativePath} → ${nextVersion}`)
+            );
+            console.log('');
+        } catch (e) {
+            showError(`Failed to update version files: ${e.message}`);
+            showWarning('Rolling back version changes and deleting branch...');
+            restoreSnapshot(snapshot);
+            try {
+                checkoutBranch(SOURCE_BRANCH);
+                execSync(`git branch -D "${rcBranch}"`, {
+                    encoding: 'utf8',
+                    stdio: ['pipe', 'pipe', 'pipe']
+                });
+            } catch {
+                // best-effort cleanup
+            }
+            process.exit(1);
+        }
+
+        // Step 8: Optional CHANGELOG
+        let selectedChangelogPath = null;
+        if (options.updateChangelog) {
+            logger.debug('create-release', 'Step 8: Generating CHANGELOG');
+            showInfo('Generating CHANGELOG entry...');
+            const changelogResult = await generateChangelogEntry({
+                version: nextVersion,
+                isReleaseVersion: true,
+                baseBranch: 'main',
+                config
+            });
+            if (changelogResult.content) {
+                selectedChangelogPath = await selectChangelogFile();
+                const updated = updateChangelogFile(changelogResult.content, selectedChangelogPath);
+                if (updated) {
+                    showSuccess('✓ CHANGELOG.md updated');
+                } else {
+                    showWarning('⚠ Failed to update CHANGELOG.md');
+                }
+            } else {
+                showWarning('⚠ No commits found for CHANGELOG');
+            }
+            console.log('');
+        }
+
+        // Stage and commit (--no-verify)
+        logger.debug('create-release', 'Staging and committing version bump');
+        showInfo('Staging and committing...');
+        const filesToStage = selectedFiles.map((f) => f.path);
+        if (options.updateChangelog) {
+            const changelogPath =
+                selectedChangelogPath || path.join(getRepoRoot(), 'CHANGELOG.md');
+            if (fs.existsSync(changelogPath)) {
+                filesToStage.push(changelogPath);
+            }
+        }
+
+        const stageResult = stageFiles(filesToStage);
+        if (!stageResult.success) {
+            showError(`Failed to stage files: ${stageResult.error}`);
+            showWarning('Rolling back...');
+            restoreSnapshot(snapshot);
+            process.exit(1);
+        }
+
+        const commitResult = createCommit(`chore(version): bump to ${nextVersion}`, {
+            noVerify: true
+        });
+        if (!commitResult.success) {
+            showError(`Failed to create commit: ${commitResult.error}`);
+            showWarning('Rolling back...');
+            restoreSnapshot(snapshot);
+            try {
+                execSync('git reset HEAD', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+            } catch {
+                // best-effort
+            }
+            process.exit(1);
+        }
+
+        showSuccess('✓ Version bump committed');
+        console.log('');
+
+        // Step 9: Create Git tag (skip silently if already exists)
+        logger.debug('create-release', 'Step 9: Creating Git tag', { tagName });
+        const tagAlreadyExists = await tagExists(tagName, 'local');
+        if (tagAlreadyExists) {
+            showWarning(`Tag ${tagName} already exists locally — skipping tag creation`);
+        } else {
+            const tagResult = createTag(nextVersion, `Release version ${nextVersion}`);
+            if (tagResult.success) {
+                showSuccess(`✓ Tag created: ${tagName}`);
+            } else {
+                showWarning(`⚠ Failed to create tag: ${tagResult.error}`);
+            }
+        }
+        console.log('');
+
+        // Step 10: Push RC branch (unless --skip-push)
+        let pushStatus = 'skipped (--skip-push)';
+        if (!options.skipPush) {
+            showInfo(`Pushing ${rcBranch} to remote...`);
+            const pushResult = pushBranch(rcBranch, { setUpstream: true });
+            if (pushResult.success) {
+                showSuccess(`✓ Pushed ${rcBranch} to remote`);
+                pushStatus = 'pushed';
+            } else {
+                showError(`Failed to push branch: ${pushResult.error}`);
+                console.log('');
+                console.log('You can push manually:');
+                console.log(`  git push -u origin ${rcBranch}`);
+                pushStatus = 'failed';
+            }
+            console.log('');
+        }
+
+        // Step 11: Deploy to shadow (unless --no-shadow or --skip-push)
+        let shadowStatus = 'skipped';
+        if (options.noShadow) {
+            showInfo('Shadow deployment skipped (--no-shadow)');
+            shadowStatus = 'skipped (--no-shadow)';
+            console.log('');
+        } else if (options.skipPush || pushStatus === 'failed') {
+            showInfo('Shadow deployment skipped — branch not pushed to remote');
+            shadowStatus = 'skipped (branch not pushed)';
+            console.log('');
+        } else {
+            showInfo('Deploying to shadow...');
+            console.log('');
+            try {
+                await runShadow(['sync', rcBranch]);
+                shadowStatus = 'synced';
+            } catch (e) {
+                showWarning(`Shadow sync encountered an error: ${e.message}`);
+                shadowStatus = 'failed';
+            }
+        }
+
+        // Step 12: Ensure we land on RC branch
+        const currentBranchAfter = getCurrentBranch();
+        if (currentBranchAfter !== rcBranch) {
+            try {
+                checkoutBranch(rcBranch);
+            } catch (e) {
+                showWarning(`Could not return to ${rcBranch}: ${e.message}`);
+            }
+        }
+
+        // Step 13: Summary
+        console.log('');
+        console.log(
+            `${colors.green}════════════════════════════════════════════════════${colors.reset}`
+        );
+        console.log(
+            `${colors.green}        Release Candidate Created ✅                 ${colors.reset}`
+        );
+        console.log(
+            `${colors.green}════════════════════════════════════════════════════${colors.reset}`
+        );
+        console.log('');
+        console.log(`${colors.blue}Branch:${colors.reset}  ${rcBranch}`);
+        console.log(`${colors.blue}Version:${colors.reset} ${nextVersion}`);
+        console.log(
+            `${colors.blue}Tag:${colors.reset}     ${tagAlreadyExists ? `${tagName} (pre-existing, skipped)` : tagName}`
+        );
+        console.log(`${colors.blue}Push:${colors.reset}    ${pushStatus}`);
+        console.log(`${colors.blue}Shadow:${colors.reset}  ${shadowStatus}`);
+        console.log('');
+
+        if (options.skipPush) {
+            console.log('Next steps:');
+            console.log(`  1. Push when ready: git push -u origin ${rcBranch}`);
+            console.log(`  2. Sync shadow:     claude-hooks shadow sync ${rcBranch}`);
+        } else {
+            console.log('Next steps:');
+            console.log('  1. Verify shadow deployment is running');
+            console.log('  2. Run QA on shadow environment');
+        }
+        console.log('');
+    } catch (e) {
+        logger.error('create-release', 'Command failed unexpectedly', e);
+        showError(`create-release failed: ${e.message}`);
+        process.exit(1);
+    }
+}