claude-git-hooks 2.15.5 → 2.16.0

package/lib/commands/bump-version.js

@@ -4,24 +4,28 @@
  *
  * Workflow:
  * 1. Validate prerequisites (clean working directory, valid branch, remote)
- * 2. Detect project type and current version
- * 3. Calculate new version with optional suffix
- * 4. Update version file(s)
- * 5. [Optional] Generate and update CHANGELOG
- * 6. Stage and commit changes (skipped with --no-commit)
- * 7. Create annotated Git tag (skipped with --no-tag or --no-commit)
- * 8. Push tag to remote (only if --push flag provided, otherwise pushed by create-pr)
+ * 2. Discover all version files recursively
+ * 3. [If mismatch OR --interactive] File selection menu
+ * 4. Calculate new version OR apply suffix operation
+ * 5. [Dry-run check]
+ * 6. Confirm with user
+ * 7. Snapshot files for rollback
+ * 8. Update version files
+ * 9. [Optional] Generate and update CHANGELOG
+ * 10. Stage and commit changes (skipped with --no-commit)
+ * 11. Create annotated Git tag (skipped with --no-tag or --no-commit)
+ * 12. Push tag to remote (only if --push flag provided, otherwise pushed by create-pr)
  */
 
 import { execSync } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 import {
-    detectProjectType,
-    getCurrentVersion,
+    discoverVersionFiles,
     incrementVersion,
-    updateVersion,
-    getDiscoveredPaths
+    modifySuffix,
+    updateVersionFiles,
+    validateVersionFormat
 } from '../utils/version-manager.js';
 import {
     createTag,
@@ -42,12 +46,20 @@ import {
     createCommit
 } from '../utils/git-operations.js';
 import { getConfig } from '../config.js';
-import { showInfo, showSuccess, showError, showWarning, promptConfirmation } from '../utils/interactive-ui.js';
+import {
+    showInfo,
+    showSuccess,
+    showError,
+    showWarning,
+    promptConfirmation,
+    promptMenu,
+    promptToggleList,
+    promptEditField
+} from '../utils/interactive-ui.js';
 import logger from '../utils/logger.js';
 import {
     colors,
     error,
-    info,
     checkGitRepo
 } from './helpers.js';
 
@@ -103,7 +115,7 @@ function validatePrerequisites() {
         logger.error('bump-version - validatePrerequisites', 'Validation failed', err);
         return {
             valid: false,
-            errors: [`Validation error: ${  err.message}`]
+            errors: [`Validation error: ${err.message}`]
         };
     }
 }
@@ -113,7 +125,7 @@ function validatePrerequisites() {
  * Why: Extracts bump type and options from CLI args
  *
  * @param {Array<string>} args - CLI arguments
- * @returns {Object} Parsed args: { bumpType, suffix, updateChangelog, baseBranch, dryRun, noTag, push, noCommit }
+ * @returns {Object} Parsed args
  */
 function parseArguments(args) {
     logger.debug('bump-version - parseArguments', 'Parsing arguments', { args });
@@ -121,31 +133,45 @@ function parseArguments(args) {
     const parsed = {
         bumpType: null,
         suffix: null,
+        removeSuffix: false,
+        setSuffix: null,
+        interactive: false,
         updateChangelog: false,
         baseBranch: 'main',
         dryRun: false,
         noTag: false,
-        push: false,      // Changed: default to NOT push (use --push to enable)
+        push: false,
         noCommit: false
     };
 
-    // First argument should be bump type
+    // First argument should be bump type (or suffix-only flags)
     if (args.length === 0) {
         return parsed;
     }
 
+    let i = 0;
+
+    // Check if first arg is bump type
     const firstArg = args[0].toLowerCase();
     if (['major', 'minor', 'patch'].includes(firstArg)) {
         parsed.bumpType = firstArg;
+        i = 1;
     }
 
     // Parse options
-    for (let i = 1; i < args.length; i++) {
+    for (; i < args.length; i++) {
         const arg = args[i];
 
         if (arg === '--suffix' && i + 1 < args.length) {
             parsed.suffix = args[i + 1];
             i++; // Skip next arg
+        } else if (arg === '--remove-suffix') {
+            parsed.removeSuffix = true;
+        } else if (arg === '--set-suffix' && i + 1 < args.length) {
+            parsed.setSuffix = args[i + 1];
+            i++; // Skip next arg
+        } else if (arg === '--interactive') {
+            parsed.interactive = true;
         } else if (arg === '--update-changelog') {
             parsed.updateChangelog = true;
             // Check if next arg is a branch name (not starting with --)
@@ -169,6 +195,50 @@ function parseArguments(args) {
     return parsed;
 }
 
+/**
+ * Displays version files discovery table
+ * Why: Show user all discovered version files
+ *
+ * @param {Object} discovery - DiscoveryResult from discoverVersionFiles()
+ */
+function displayDiscoveryTable(discovery) {
+    console.log('');
+    console.log(`${colors.blue}═══════════════════════════════════════════════════════════════${colors.reset}`);
+    console.log(`${colors.blue}                   Version Files Discovery                      ${colors.reset}`);
+    console.log(`${colors.blue}═══════════════════════════════════════════════════════════════${colors.reset}`);
+    console.log('');
+
+    if (discovery.files.length === 0) {
+        console.log('  No version files found.');
+        console.log('');
+        return;
+    }
+
+    // Table header
+    console.log(`  ${'#'.padEnd(3)} ${'File'.padEnd(35)} ${'Type'.padEnd(15)} ${'Version'.padEnd(15)}`);
+    console.log(`  ${'-'.repeat(3)} ${'-'.repeat(35)} ${'-'.repeat(15)} ${'-'.repeat(15)}`);
+
+    // Table rows
+    discovery.files.forEach((file, index) => {
+        const num = `${index + 1}`.padEnd(3);
+        const filePath = file.relativePath.padEnd(35);
+        const fileType = file.projectLabel.padEnd(15);
+        const version = file.version ? file.version.padEnd(15) : 'N/A'.padEnd(15);
+        const mismatchMarker = discovery.mismatch && file.version !== discovery.resolvedVersion ? ' ⚠️ ' : '';
+
+        console.log(`  ${num} ${filePath} ${fileType} ${version}${mismatchMarker}`);
+    });
+
+    console.log('');
+    console.log(`  Resolved version: ${discovery.resolvedVersion || 'N/A'}`);
+
+    if (discovery.mismatch) {
+        console.log(`  ${colors.yellow}⚠️  Version mismatch detected${colors.reset}`);
+    }
+
+    console.log('');
+}
+
 /**
  * Displays dry run preview
  * Why: Shows what would change without applying
@@ -181,15 +251,21 @@ function showDryRunPreview(info) {
     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}Project Type:${colors.reset} ${info.projectType}`);
+
+    displayDiscoveryTable(info.discovery);
+
+    console.log(`${colors.blue}Operation:${colors.reset} ${info.operation}`);
     console.log(`${colors.blue}Current Version:${colors.reset} ${info.currentVersion}`);
     console.log(`${colors.green}New Version:${colors.reset} ${info.newVersion}`);
     console.log(`${colors.blue}Tag Name:${colors.reset} ${info.tagName}`);
     console.log('');
 
-    if (info.files.length > 0) {
+    if (info.selectedFiles.length > 0) {
         console.log(`${colors.blue}Files to update:${colors.reset}`);
-        info.files.forEach(file => console.log(`  - ${file}`));
+        info.selectedFiles.forEach(file => {
+            const targetVer = file.targetVersion || info.newVersion;
+            console.log(`  - ${file.relativePath} (${file.version} → ${targetVer})`);
+        });
         console.log('');
     }
 
@@ -202,6 +278,100 @@ function showDryRunPreview(info) {
     console.log('');
 }
 
+/**
+ * Prompts user for file selection when mismatch or --interactive
+ * Why: Let user choose which files to update
+ *
+ * @param {Object} discovery - DiscoveryResult
+ * @returns {Promise<Array>} Selected files
+ */
+async function promptFileSelection(discovery) {
+    console.log('');
+    showWarning('Version mismatch detected or interactive mode enabled');
+    console.log('');
+
+    const options = [
+        { key: 'a', label: 'Update all files' },
+        { key: 's', label: 'Select which files to update' },
+        { key: 'e', label: 'Edit version per file (advanced)' },
+        { key: 'c', label: 'Cancel' }
+    ];
+
+    const choice = await promptMenu('Choose action:', options, 'a');
+
+    if (choice === 'c') {
+        showInfo('Version bump cancelled');
+        process.exit(0);
+    }
+
+    if (choice === 'a') {
+        // All files selected
+        return discovery.files;
+    }
+
+    if (choice === 's') {
+        // Toggle list selection
+        const items = discovery.files.map((file, index) => ({
+            key: `${index}`,
+            label: `${file.relativePath} (${file.projectLabel}) - ${file.version || 'N/A'}`,
+            selected: file.selected
+        }));
+
+        const selectedKeys = await promptToggleList(
+            'Select files to update (type number to toggle, Enter to confirm):',
+            items
+        );
+
+        // Filter files by selected keys
+        return discovery.files.filter((_, index) => selectedKeys.includes(`${index}`));
+    }
+
+    if (choice === 'e') {
+        // Per-file version editing
+        showInfo('Enter target version for each file (press Enter to keep calculated version)');
+        console.log('');
+
+        for (const file of discovery.files) {
+            const input = await promptEditField(
+                `${file.relativePath} (${file.projectLabel})`,
+                file.version || 'N/A'
+            );
+
+            // If user entered something different from current version, store it
+            if (input !== file.version && input !== 'N/A') {
+                if (!validateVersionFormat(input)) {
+                    showWarning(`Invalid version format: ${input} — skipping ${file.relativePath}`);
+                    continue;
+                }
+                file.targetVersion = input;
+            }
+        }
+
+        return discovery.files;
+    }
+
+    return discovery.files;
+}
+
+/**
+ * Restores files from a snapshot map
+ * Why: Centralized rollback logic used by multiple error paths
+ *
+ * @param {Map<string, string>} snapshot - Map of filePath → original content
+ */
+function restoreSnapshot(snapshot) {
+    snapshot.forEach((content, filePath) => {
+        try {
+            fs.writeFileSync(filePath, content, 'utf8');
+        } catch (rollbackErr) {
+            logger.error('bump-version', 'Rollback failed', {
+                path: filePath,
+                error: rollbackErr.message
+            });
+        }
+    });
+}
+
 /**
  * Bump version command
  * @param {Array<string>} args - Command arguments
@@ -212,25 +382,40 @@ export async function runBumpVersion(args) {
     // Parse arguments
     const options = parseArguments(args);
 
-    if (!options.bumpType) {
+    // Determine if this is a suffix-only operation
+    const isSuffixOnly = (options.removeSuffix || options.setSuffix) && !options.bumpType;
+
+    // Validate arguments
+    if (!options.bumpType && !isSuffixOnly) {
         error('Usage: claude-hooks bump-version <major|minor|patch> [options]');
+        error('   or: claude-hooks bump-version --remove-suffix [options]');
+        error('   or: claude-hooks bump-version --set-suffix <value> [options]');
         console.log('');
         console.log('Options:');
-        console.log('  --suffix <value>         Add version suffix (e.g., SNAPSHOT, RC)');
+        console.log('  --suffix <value>          Add version suffix (e.g., SNAPSHOT, RC)');
+        console.log('  --remove-suffix           Remove version suffix (2.15.5-SNAPSHOT → 2.15.5)');
+        console.log('  --set-suffix <value>      Set/replace suffix (2.15.5 → 2.15.5-SNAPSHOT)');
+        console.log('  --interactive             Force interactive file selection menu');
         console.log('  --update-changelog [branch]  Generate CHANGELOG entry (default branch: main)');
-        console.log('  --dry-run                Preview changes without applying');
-        console.log('  --no-tag                 Skip Git tag creation');
-        console.log('  --push                   Push tag to remote (default: tags stay local)');
-        console.log('  --no-commit              Skip automatic commit (manual workflow)');
+        console.log('  --dry-run                 Preview changes without applying');
+        console.log('  --no-tag                  Skip Git tag creation');
+        console.log('  --push                    Push tag to remote (default: tags stay local)');
+        console.log('  --no-commit               Skip automatic commit (manual workflow)');
         console.log('');
         console.log('Examples:');
         console.log('  claude-hooks bump-version minor --suffix SNAPSHOT');
         console.log('  claude-hooks bump-version patch --update-changelog');
+        console.log('  claude-hooks bump-version --remove-suffix');
+        console.log('  claude-hooks bump-version --set-suffix RC1');
         console.log('  claude-hooks bump-version major --dry-run');
         return;
     }
 
-    showInfo(`🔢 Bumping version (${options.bumpType})...`);
+    if (isSuffixOnly) {
+        showInfo('🔧 Performing suffix-only operation...');
+    } else {
+        showInfo(`🔢 Bumping version (${options.bumpType})...`);
+    }
     console.log('');
 
     // Step 1: Validate prerequisites
@@ -252,86 +437,92 @@ export async function runBumpVersion(args) {
 
     showSuccess('Prerequisites validated');
 
-    // Step 2: Detect project type and current version
-    logger.debug('bump-version', 'Step 2: Detecting project type and version');
-    const projectType = detectProjectType();
+    // Step 2: Discover all version files
+    logger.debug('bump-version', 'Step 2: Discovering version files');
+    const discovery = discoverVersionFiles();
 
-    if (projectType === 'none') {
+    if (discovery.files.length === 0) {
         showError('No version files found');
         console.log('');
-        console.log('This command requires either:');
-        console.log('  - package.json (Node.js project)');
-        console.log('  - pom.xml (Maven project)');
+        console.log('This command requires at least one of:');
+        console.log('  - package.json (Node.js)');
+        console.log('  - pom.xml (Maven)');
+        console.log('  - build.gradle (Gradle)');
+        console.log('  - build.gradle.kts (Gradle Kotlin)');
+        console.log('  - pyproject.toml (Python)');
+        console.log('  - Cargo.toml (Rust)');
+        console.log('  - version.sbt (Scala/sbt)');
         console.log('');
-        console.log('Searched in repository root and one level deep in subdirectories.');
+        console.log('Searched recursively up to 3 levels deep.');
         console.log('');
         process.exit(1);
     }
 
-    // Show discovered paths
-    const paths = getDiscoveredPaths();
-    const repoRoot = getRepoRoot();
-    if (paths.packageJson) {
-        const relativePath = path.relative(repoRoot, paths.packageJson);
-        info(`Found package.json: ${relativePath}`);
-    }
-    if (paths.pomXml) {
-        const relativePath = path.relative(repoRoot, paths.pomXml);
-        info(`Found pom.xml: ${relativePath}`);
-    }
+    // Display discovery table
+    displayDiscoveryTable(discovery);
 
-    const versions = getCurrentVersion(projectType);
-    const currentVersion = versions.resolved;
+    const currentVersion = discovery.resolvedVersion;
 
     if (!currentVersion) {
-        showError('Could not determine current version');
+        showError('Could not determine current version from discovered files');
         process.exit(1);
     }
 
-    // Warn if monorepo has version mismatch
-    if (versions.mismatch) {
-        showWarning('Version mismatch detected in monorepo:');
-        console.log(`  package.json: ${versions.packageJson}`);
-        console.log(`  pom.xml: ${versions.pomXml}`);
-        console.log('');
-        console.log('Both files will be updated to the new version.');
+    showInfo(`Current version: ${currentVersion}`);
+
+    // Step 3: File selection (if mismatch or interactive mode)
+    let selectedFiles = discovery.files.filter(f => f.selected);
+
+    if (discovery.mismatch || options.interactive) {
+        selectedFiles = await promptFileSelection(discovery);
+
+        if (selectedFiles.length === 0) {
+            showError('No files selected');
+            process.exit(1);
+        }
+
+        showSuccess(`${selectedFiles.length} file(s) selected for update`);
         console.log('');
     }
 
-    showInfo(`Project: ${projectType}`);
-    showInfo(`Current version: ${currentVersion}`);
+    // Step 4: Calculate new version or apply suffix operation
+    logger.debug('bump-version', 'Step 4: Calculating new version');
+    let newVersion;
+    let operation;
+
+    if (isSuffixOnly) {
+        if (options.removeSuffix) {
+            newVersion = modifySuffix(currentVersion, { remove: true });
+            operation = 'Remove suffix';
+        } else if (options.setSuffix) {
+            newVersion = modifySuffix(currentVersion, { set: options.setSuffix });
+            operation = `Set suffix to ${options.setSuffix}`;
+        }
+    } else {
+        newVersion = incrementVersion(currentVersion, options.bumpType, options.suffix || options.setSuffix);
+        operation = `Bump ${options.bumpType}`;
+    }
 
-    // Step 3: Calculate new version
-    logger.debug('bump-version', 'Step 3: Calculating new version');
-    const newVersion = incrementVersion(currentVersion, options.bumpType, options.suffix);
     const tagName = formatTagName(newVersion);
 
     showSuccess(`New version: ${newVersion}`);
     console.log('');
 
-    // Prepare files list
-    const filesToUpdate = [];
-    if (projectType === 'node' || projectType === 'both') {
-        filesToUpdate.push('package.json');
-    }
-    if (projectType === 'maven' || projectType === 'both') {
-        filesToUpdate.push('pom.xml');
-    }
-
-    // Dry run preview
+    // Step 5: Dry run preview
     if (options.dryRun) {
         showDryRunPreview({
-            projectType,
+            discovery,
+            operation,
             currentVersion,
             newVersion,
             tagName,
-            files: filesToUpdate,
+            selectedFiles,
             updateChangelog: options.updateChangelog
         });
         return;
     }
 
-    // Confirm with user
+    // Step 6: Confirm with user
     const shouldContinue = await promptConfirmation(
         `Update version to ${newVersion}?`,
         true
@@ -350,23 +541,53 @@ export async function runBumpVersion(args) {
         const defaultBranch = config.github?.pr?.defaultBase || '{target-branch}';
         logger.debug('bump-version', 'Default branch for PR', { defaultBranch });
 
-        // Step 4: Update version files
-        logger.debug('bump-version', 'Step 4: Updating version files');
-        showInfo('Updating version files...');
-        updateVersion(projectType, newVersion);
+        // Step 7: Snapshot files for rollback
+        logger.debug('bump-version', 'Step 7: Creating snapshot for rollback');
+        const snapshot = new Map();
+        selectedFiles.forEach(file => {
+            try {
+                const content = fs.readFileSync(file.path, 'utf8');
+                snapshot.set(file.path, content);
+            } catch (err) {
+                logger.error('bump-version', 'Failed to snapshot file', {
+                    path: file.path,
+                    error: err.message
+                });
+            }
+        });
 
-        filesToUpdate.forEach(file => {
-            showSuccess(`✓ Updated ${file}`);
+        logger.debug('bump-version', 'Snapshot created', {
+            fileCount: snapshot.size
         });
 
-        console.log('');
+        // Step 8: Update version files
+        logger.debug('bump-version', 'Step 8: Updating version files');
+        showInfo('Updating version files...');
 
-        // Step 5: Generate CHANGELOG (if requested)
+        try {
+            updateVersionFiles(selectedFiles, newVersion);
+
+            selectedFiles.forEach(file => {
+                const targetVer = file.targetVersion || newVersion;
+                showSuccess(`✓ Updated ${file.relativePath} → ${targetVer}`);
+            });
+
+            console.log('');
+        } catch (err) {
+            // Rollback on failure
+            showError(`Failed to update version files: ${err.message}`);
+            showWarning('Rolling back changes...');
+            restoreSnapshot(snapshot);
+            showSuccess('Changes rolled back');
+            process.exit(1);
+        }
+
+        // Step 9: Generate CHANGELOG (if requested)
         if (options.updateChangelog) {
-            logger.debug('bump-version', 'Step 5: Generating CHANGELOG');
+            logger.debug('bump-version', 'Step 9: Generating CHANGELOG');
             showInfo('Generating CHANGELOG entry...');
 
-            const isReleaseVersion = !options.suffix; // Final version if no suffix
+            const isReleaseVersion = !options.suffix && !options.setSuffix;
 
             const changelogResult = await generateChangelogEntry({
                 version: newVersion,
@@ -389,24 +610,15 @@ export async function runBumpVersion(args) {
             console.log('');
         }
 
-        // Step 6: Stage and commit changes
+        // Step 10: Stage and commit changes
         let commitCreated = false;
 
         if (!options.noCommit) {
-            logger.debug('bump-version', 'Step 6: Staging and committing changes');
+            logger.debug('bump-version', 'Step 10: Staging and committing changes');
             showInfo('Staging and committing changes...');
 
             // Collect files to stage
-            const filesToStage = [];
-
-            // Add discovered version files
-            const paths = getDiscoveredPaths();
-            if (paths.packageJson) {
-                filesToStage.push(paths.packageJson);
-            }
-            if (paths.pomXml) {
-                filesToStage.push(paths.pomXml);
-            }
+            const filesToStage = selectedFiles.map(f => f.path);
 
             // Add CHANGELOG if it was updated
             if (options.updateChangelog) {
@@ -425,26 +637,39 @@ export async function runBumpVersion(args) {
                 console.log('Files that should be staged:');
                 filesToStage.forEach(f => console.log(`  - ${path.relative(getRepoRoot(), f)}`));
                 console.log('');
-                console.log('You can stage and commit manually:');
-                console.log(`  git add ${filesToUpdate.join(' ')}`);
-                if (options.updateChangelog) {
-                    console.log('  git add CHANGELOG.md');
-                }
-                console.log(`  git commit -m "chore(version): bump to ${newVersion}"`);
+
+                // Rollback version changes
+                showWarning('Rolling back version changes...');
+                restoreSnapshot(snapshot);
+                showSuccess('Changes rolled back');
                 process.exit(1);
             }
 
             showSuccess(`✓ Staged ${stageResult.stagedFiles.length} file(s)`);
 
             // Create commit
-            const commitMessage = `chore(version): bump to ${newVersion}`;
+            const commitMessage = isSuffixOnly
+                ? `chore(version): update suffix to ${newVersion}`
+                : `chore(version): bump to ${newVersion}`;
+
             const commitResult = createCommit(commitMessage, { noVerify: true });
 
             if (!commitResult.success) {
                 showError(`Failed to create commit: ${commitResult.error}`);
                 console.log('');
-                console.log('Files have been staged. You can commit manually:');
-                console.log(`  git commit -m "chore(version): bump to ${newVersion}"`);
+
+                // Rollback version changes and unstage
+                showWarning('Rolling back version changes...');
+                restoreSnapshot(snapshot);
+
+                // Unstage files
+                try {
+                    execSync('git reset HEAD', { encoding: 'utf8' });
+                } catch (unstageErr) {
+                    logger.error('bump-version', 'Failed to unstage', unstageErr);
+                }
+
+                showSuccess('Changes rolled back');
                 process.exit(1);
             }
 
@@ -456,9 +681,9 @@ export async function runBumpVersion(args) {
             console.log('');
         }
 
-        // Step 7: Create Git tag (if not disabled)
+        // Step 11: Create Git tag (if not disabled)
         if (!options.noTag) {
-            logger.debug('bump-version', 'Step 7: Creating Git tag');
+            logger.debug('bump-version', 'Step 11: Creating Git tag');
 
             // Prevent tag creation if changes not committed
             if (options.noCommit) {
@@ -495,9 +720,9 @@ export async function runBumpVersion(args) {
                     showSuccess(`✓ Tag created: ${tagName}`);
                     console.log('');
 
-                    // Step 8: Push tag (if --push flag provided)
+                    // Step 12: Push tag (if --push flag provided)
                     if (options.push) {
-                        logger.debug('bump-version', 'Step 8: Pushing tag to remote');
+                        logger.debug('bump-version', 'Step 12: Pushing tag to remote');
                         showInfo('Pushing tag to remote...');
 
                         const pushResult = pushTags(null, tagName);
@@ -530,6 +755,15 @@ export async function runBumpVersion(args) {
         console.log(`${colors.green}        Version Bump Complete ✅                ${colors.reset}`);
         console.log(`${colors.green}════════════════════════════════════════════════${colors.reset}`);
         console.log('');
+
+        // Show updated files table
+        console.log(`${colors.blue}Updated files:${colors.reset}`);
+        selectedFiles.forEach(file => {
+            const targetVer = file.targetVersion || newVersion;
+            console.log(`  ✓ ${file.relativePath} (${file.projectLabel}) - ${file.version} → ${targetVer}`);
+        });
+        console.log('');
+
         console.log(`${colors.blue}Old version:${colors.reset} ${currentVersion}`);
         console.log(`${colors.blue}New version:${colors.reset} ${newVersion}`);
         console.log(`${colors.blue}Tag:${colors.reset} ${tagName}`);
@@ -539,7 +773,7 @@ export async function runBumpVersion(args) {
         if (options.noCommit) {
             console.log('Next steps:');
             console.log('  1. Review changes: git diff');
-            console.log(`  2. Stage files: git add ${filesToUpdate.join(' ')}`);
+            console.log('  2. Stage files: git add <files>');
             if (options.updateChangelog) {
                 console.log('     git add CHANGELOG.md');
             }
@@ -566,9 +800,7 @@ export async function runBumpVersion(args) {
         logger.error('bump-version', 'Version bump failed', err);
         showError(`Version bump failed: ${err.message}`);
         console.log('');
-        console.log('The operation was interrupted. You may need to:');
-        console.log('  - Revert changes: git checkout .');
-        console.log(`  - Delete tag if created: git tag -d ${  tagName}`);
+        console.log('The operation was interrupted.');
         console.log('');
         process.exit(1);
     }