chore(devtools): QOL improvements for cherry-pick script (#6620)

Author: jmelahman

tools/ods/cmd/cherry-pick.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"bufio"
 	"fmt"
 	"os"
 	"os/exec"
@@ -14,39 +15,55 @@ import (
 // CherryPickOptions holds options for the cherry-pick command
 type CherryPickOptions struct {
 	Releases []string
+	DryRun   bool
+	Yes      bool
 }
 
 // NewCherryPickCommand creates a new cherry-pick command
 func NewCherryPickCommand() *cobra.Command {
 	opts := &CherryPickOptions{}
 
 	cmd := &cobra.Command{
-		Use:   "cherry-pick <commit-sha>",
-		Short: "Cherry-pick a commit to a release branch",
-		Long: `Cherry-pick a commit to a release branch and create a PR.
+		Use:   "cherry-pick <commit-sha> [<commit-sha>...]",
+		Short: "Cherry-pick one or more commits to a release branch",
+		Long: `Cherry-pick one or more commits to a release branch and create a PR.
 
 This command will:
-  1. Find the nearest stable version tag (v*.*.* if --release not specified)
-  2. Fetch the corresponding release branch (release/vMAJOR.MINOR)
-  3. Create a hotfix branch with the cherry-picked commit
+  1. Find the nearest stable version tag
+  2. Fetch the corresponding release branch(es)
+  3. Create a hotfix branch with the cherry-picked commit(s)
   4. Push and create a PR using the GitHub CLI
   5. Switch back to the original branch
 
-The --release flag can be specified multiple times to cherry-pick to multiple release branches.`,
-		Args: cobra.ExactArgs(1),
+Multiple commits will be cherry-picked in the order specified, similar to git cherry-pick.
+The --release flag can be specified multiple times to cherry-pick to multiple release branches.
+Example usage:
+
+	$ ods cherry-pick foo123 bar456 --release 2.5 --release 2.6`,
+		Args: cobra.MinimumNArgs(1),
 		Run: func(cmd *cobra.Command, args []string) {
 			runCherryPick(cmd, args, opts)
 		},
 	}
 
 	cmd.Flags().StringSliceVar(&opts.Releases, "release", []string{}, "Release version(s) to cherry-pick to (e.g., 1.0, v1.1). 'v' prefix is optional. Can be specified multiple times.")
+	cmd.Flags().BoolVar(&opts.DryRun, "dry-run", false, "Perform all local operations but skip pushing to remote and creating PRs")
+	cmd.Flags().BoolVar(&opts.Yes, "yes", false, "Skip confirmation prompts and automatically proceed")
 
 	return cmd
 }
 
 func runCherryPick(cmd *cobra.Command, args []string, opts *CherryPickOptions) {
-	commitSHA := args[0]
-	log.Debugf("Cherry-picking commit: %s", commitSHA)
+	commitSHAs := args
+	if len(commitSHAs) == 1 {
+		log.Debugf("Cherry-picking commit: %s", commitSHAs[0])
+	} else {
+		log.Debugf("Cherry-picking %d commits: %s", len(commitSHAs), strings.Join(commitSHAs, ", "))
+	}
+
+	if opts.DryRun {
+		log.Warning("=== DRY RUN MODE: No remote operations will be performed ===")
+	}
 
 	// Save the current branch to switch back later
 	originalBranch, err := getCurrentBranch()
@@ -55,10 +72,25 @@ func runCherryPick(cmd *cobra.Command, args []string, opts *CherryPickOptions) {
 	}
 	log.Debugf("Original branch: %s", originalBranch)
 
-	// Get the short SHA for branch naming
-	shortSHA := commitSHA
-	if len(shortSHA) > 8 {
-		shortSHA = shortSHA[:8]
+	// Get the short SHA(s) for branch naming
+	var branchSuffix string
+	if len(commitSHAs) == 1 {
+		shortSHA := commitSHAs[0]
+		if len(shortSHA) > 8 {
+			shortSHA = shortSHA[:8]
+		}
+		branchSuffix = shortSHA
+	} else {
+		// For multiple commits, use first-last notation
+		firstSHA := commitSHAs[0]
+		lastSHA := commitSHAs[len(commitSHAs)-1]
+		if len(firstSHA) > 8 {
+			firstSHA = firstSHA[:8]
+		}
+		if len(lastSHA) > 8 {
+			lastSHA = lastSHA[:8]
+		}
+		branchSuffix = fmt.Sprintf("%s-%s", firstSHA, lastSHA)
 	}
 
 	// Determine which releases to target
@@ -68,84 +100,121 @@ func runCherryPick(cmd *cobra.Command, args []string, opts *CherryPickOptions) {
 		for _, rel := range opts.Releases {
 			releases = append(releases, normalizeVersion(rel))
 		}
-		log.Infof("Using specified release versions: %v", releases)
+		log.Debugf("Using specified release versions: %v", releases)
 	} else {
-		// Find the nearest stable tag
-		version, err := findNearestStableTag(commitSHA)
+		// Find the nearest stable tag using the first commit
+		version, err := findNearestStableTag(commitSHAs[0])
 		if err != nil {
 			log.Fatalf("Failed to find nearest stable tag: %v", err)
 		}
+
+		// Prompt user for confirmation
+		if !opts.Yes {
+			if !promptYesNo(fmt.Sprintf("Auto-detected release version: %s. Continue? (yes/no): ", version)) {
+				log.Info("If you want to cherry-pick to a different release, use the --release flag. Exiting...")
+				return
+			}
+		} else {
+			log.Infof("Auto-detected release version: %s", version)
+		}
+
 		releases = []string{version}
-		log.Infof("Auto-detected release version: %s", version)
 	}
 
-	// Get commit message for PR title
-	commitMsg, err := getCommitMessage(commitSHA)
-	if err != nil {
-		log.Warnf("Failed to get commit message, using default title: %v", err)
-		commitMsg = fmt.Sprintf("Hotfix: cherry-pick %s", shortSHA)
+	// Get commit message(s) for PR title
+	var prTitle string
+	if len(commitSHAs) == 1 {
+		commitMsg, err := getCommitMessage(commitSHAs[0])
+		if err != nil {
+			log.Warnf("Failed to get commit message, using default title: %v", err)
+			shortSHA := commitSHAs[0]
+			if len(shortSHA) > 8 {
+				shortSHA = shortSHA[:8]
+			}
+			prTitle = fmt.Sprintf("chore(hotfix): cherry-pick %s", shortSHA)
+		} else {
+			prTitle = commitMsg
+		}
+	} else {
+		// For multiple commits, use a generic title
+		prTitle = fmt.Sprintf("chore(hotfix): cherry-pick %d commits", len(commitSHAs))
 	}
 
 	// Process each release
 	prURLs := []string{}
 	for _, release := range releases {
-		log.Infof("\n--- Processing release %s ---", release)
-		prURL, err := cherryPickToRelease(commitSHA, shortSHA, release, commitMsg)
+		log.Infof("Processing release %s", release)
+		prTitleWithRelease := fmt.Sprintf("%s to release %s", prTitle, release)
+		prURL, err := cherryPickToRelease(commitSHAs, branchSuffix, release, prTitleWithRelease, opts.DryRun)
 		if err != nil {
 			// Switch back to original branch before exiting on error
-			if checkoutErr := runGitCommand("checkout", originalBranch); checkoutErr != nil {
-				log.Warnf("Failed to switch back to original branch: %v", checkoutErr)
+			if switchErr := runGitCommand("switch", "--quiet", originalBranch); switchErr != nil {
+				log.Warnf("Failed to switch back to original branch: %v", switchErr)
 			}
 			log.Fatalf("Failed to cherry-pick to release %s: %v", release, err)
 		}
-		prURLs = append(prURLs, prURL)
+		if prURL != "" {
+			prURLs = append(prURLs, prURL)
+		}
 	}
 
 	// Switch back to the original branch
-	log.Infof("\nSwitching back to original branch: %s", originalBranch)
-	if err := runGitCommand("checkout", originalBranch); err != nil {
+	log.Infof("Switching back to original branch: %s", originalBranch)
+	if err := runGitCommand("switch", "--quiet", originalBranch); err != nil {
 		log.Warnf("Failed to switch back to original branch: %v", err)
 	}
 
 	// Print all PR URLs
-	log.Info("\n=== Summary ===")
 	for i, prURL := range prURLs {
 		log.Infof("PR %d: %s", i+1, prURL)
 	}
 }
 
-// cherryPickToRelease cherry-picks a commit to a specific release branch
-func cherryPickToRelease(commitSHA, shortSHA, version, commitMsg string) (string, error) {
+// cherryPickToRelease cherry-picks one or more commits to a specific release branch
+func cherryPickToRelease(commitSHAs []string, branchSuffix, version, prTitle string, dryRun bool) (string, error) {
 	releaseBranch := fmt.Sprintf("release/%s", version)
-	hotfixBranch := fmt.Sprintf("hotfix/%s-%s", shortSHA, version)
+	hotfixBranch := fmt.Sprintf("hotfix/%s-%s", branchSuffix, version)
 
 	// Fetch the release branch
 	log.Infof("Fetching release branch: %s", releaseBranch)
-	if err := runGitCommand("fetch", "origin", releaseBranch); err != nil {
+	if err := runGitCommand("fetch", "--prune", "--quiet", "origin", releaseBranch); err != nil {
 		return "", fmt.Errorf("failed to fetch release branch %s: %w", releaseBranch, err)
 	}
 
 	// Create the hotfix branch from the release branch
 	log.Infof("Creating hotfix branch: %s", hotfixBranch)
-	if err := runGitCommand("checkout", "-b", hotfixBranch, fmt.Sprintf("origin/%s", releaseBranch)); err != nil {
+	if err := runGitCommand("checkout", "--quiet", "-b", hotfixBranch, fmt.Sprintf("origin/%s", releaseBranch)); err != nil {
 		return "", fmt.Errorf("failed to create hotfix branch: %w", err)
 	}
 
-	// Cherry-pick the commit
-	log.Infof("Cherry-picking commit: %s", commitSHA)
-	if err := runGitCommand("cherry-pick", commitSHA); err != nil {
-		return "", fmt.Errorf("failed to cherry-pick commit: %w", err)
+	// Cherry-pick the commits
+	if len(commitSHAs) == 1 {
+		log.Infof("Cherry-picking commit: %s", commitSHAs[0])
+	} else {
+		log.Infof("Cherry-picking %d commits: %s", len(commitSHAs), strings.Join(commitSHAs, " "))
+	}
+
+	// Build git cherry-pick command with all commits
+	cherryPickArgs := append([]string{"cherry-pick"}, commitSHAs...)
+	if err := runGitCommand(cherryPickArgs...); err != nil {
+		return "", fmt.Errorf("failed to cherry-pick commits: %w", err)
+	}
+
+	if dryRun {
+		log.Warnf("[DRY RUN] Would push hotfix branch: %s", hotfixBranch)
+		log.Warnf("[DRY RUN] Would create PR from %s to %s", hotfixBranch, releaseBranch)
+		return "", nil
 	}
 
 	// Push the hotfix branch
 	log.Infof("Pushing hotfix branch: %s", hotfixBranch)
-	if err := runGitCommand("push", "-u", "origin", hotfixBranch); err != nil {
+	if err := runGitCommand("push", "--quiet", "-u", "origin", hotfixBranch); err != nil {
 		return "", fmt.Errorf("failed to push hotfix branch: %w", err)
 	}
 
 	// Create PR using GitHub CLI
 	log.Info("Creating PR...")
-	prURL, err := createPR(hotfixBranch, releaseBranch, commitMsg, commitSHA)
+	prURL, err := createPR(hotfixBranch, releaseBranch, prTitle, commitSHAs)
 	if err != nil {
 		return "", fmt.Errorf("failed to create PR: %w", err)
 	}
@@ -154,12 +223,32 @@ func cherryPickToRelease(commitSHA, shortSHA, version, commitMsg string) (string
 	return prURL, nil
 }
 
+// promptYesNo prompts the user with a yes/no question and returns true for yes, false for no
+func promptYesNo(prompt string) bool {
+	reader := bufio.NewReader(os.Stdin)
+	for {
+		fmt.Print(prompt)
+		response, err := reader.ReadString('\n')
+		if err != nil {
+			log.Fatalf("Failed to read input: %v", err)
+		}
+		response = strings.TrimSpace(strings.ToLower(response))
+		if response == "yes" || response == "y" || response == "" {
+			return true
+		}
+		if response == "no" || response == "n" {
+			return false
+		}
+		fmt.Println("Please enter 'yes' or 'no'")
+	}
+}
+
 // getCurrentBranch returns the name of the current git branch
 func getCurrentBranch() (string, error) {
-	cmd := exec.Command("git", "rev-parse", "--abbrev-ref", "HEAD")
+	cmd := exec.Command("git", "branch", "--show-current")
 	output, err := cmd.Output()
 	if err != nil {
-		return "", fmt.Errorf("git rev-parse failed: %w", err)
+		return "", fmt.Errorf("git branch failed: %w", err)
 	}
 	return strings.TrimSpace(string(output)), nil
 }
@@ -198,7 +287,9 @@ func findNearestStableTag(commitSHA string) (string, error) {
 func runGitCommand(args ...string) error {
 	log.Debugf("Running: git %s", strings.Join(args, " "))
 	cmd := exec.Command("git", args...)
-	cmd.Stdout = os.Stdout
+	if log.IsLevelEnabled(log.DebugLevel) {
+		cmd.Stdout = os.Stdout
+	}
 	cmd.Stderr = os.Stderr
 	return cmd.Run()
 }
@@ -214,8 +305,16 @@ func getCommitMessage(commitSHA string) (string, error) {
 }
 
 // createPR creates a pull request using the GitHub CLI
-func createPR(headBranch, baseBranch, title, commitSHA string) (string, error) {
-	body := fmt.Sprintf("Cherry-pick of commit %s to %s branch.", commitSHA, baseBranch)
+func createPR(headBranch, baseBranch, title string, commitSHAs []string) (string, error) {
+	var body string
+	if len(commitSHAs) == 1 {
+		body = fmt.Sprintf("Cherry-pick of commit %s to %s branch.", commitSHAs[0], baseBranch)
+	} else {
+		body = fmt.Sprintf("Cherry-pick of %d commits to %s branch:\n\n", len(commitSHAs), baseBranch)
+		for _, sha := range commitSHAs {
+			body += fmt.Sprintf("- %s\n", sha)
+		}
+	}
 
 	cmd := exec.Command("gh", "pr", "create",
 		"--base", baseBranch,

tools/ods/cmd/root.go

@@ -31,6 +31,9 @@ func NewRootCommand() *cobra.Command {
 			} else {
 				log.SetLevel(log.InfoLevel)
 			}
+			log.SetFormatter(&log.TextFormatter{
+				DisableTimestamp: true,
+			})
 		},
 		Version: fmt.Sprintf("%s\ncommit %s", Version, Commit),
 	}