Fix other minor inconsistencies

Author: slack-jallen

commands/command_add_description.go

@@ -39,7 +39,7 @@ func createAddDescriptionCommand() *cobra.Command {
 			MultiSelect: true,
 		}
 		aiCommand := ai.GetAiCommandInteractive()
-		slog.Info(fmt.Sprint("commands", aiCommand))
+		slog.Info(fmt.Sprint("command: ", aiCommand))
 		targetCommits := getTargetCommits(args, indicatorTypeString, selectPrsOptions)
 		executeAddDescription(targetCommits)
 	}
@@ -90,9 +90,12 @@ func parseDescription(aiOutput string) string {
 			break
 		}
 	}
+	beginLen := 0
 	if start == -1 {
 		slog.Warn("Missing markdown start (" + fmt.Sprint(begins) + ") in claude output")
 		start = 0
+	} else {
+		beginLen = len(begins[beginIndex])
 	}
 	end := -1
 	for _, nextEnd := range ends {
@@ -105,7 +108,7 @@ func parseDescription(aiOutput string) string {
 		slog.Debug("Missing markdown end (" + fmt.Sprint(ends) + ") in claude output")
 		end = len(aiOutput[start:])
 	}
-	return string(aiOutput[start+len(begins[beginIndex]) : start+end])
+	return string(aiOutput[start+beginLen : start+end])
 }
 
 func getNewPrBody(pr gitutil.PrInfo, description string) string {

commands/command_migrate.go

@@ -46,7 +46,7 @@ func executeMigrate() {
 	// Step 1: Find all local branches where the current user has made commits
 	slog.Debug("Step 1: Finding user branches...")
 	userBranches := findUserBranches()
-	slog.Debug(fmt.Sprintf("Step 1 complete: Found %d user branches", len(userBranches)))
+	slog.Debug(fmt.Sprint("Step 1 complete: Found ", len(userBranches), " user branches"))
 
 	if len(userBranches) == 0 {
 		util.Fprintln(appConfig.Io.Out, "No branches found with your commits")
@@ -56,18 +56,18 @@ func executeMigrate() {
 	// Step 2: Display branches to user for selection
 	slog.Debug("Step 2: Selecting branches to migrate...")
 	selectedBranches := selectBranchesToMigrate(userBranches)
-	slog.Debug(fmt.Sprintf("Step 2 complete: Selected %d branches", len(selectedBranches)))
+	slog.Debug(fmt.Sprint("Step 2 complete: Selected ", len(selectedBranches), " branches"))
 
 	if len(selectedBranches) == 0 {
 		slog.Debug("No branches selected for migration")
 		appConfig.Exit(0)
 	}
 
-	slog.Debug(fmt.Sprintf("Selected %d branches for migration: %v", len(selectedBranches), selectedBranches))
+	slog.Debug(fmt.Sprint("Selected ", len(selectedBranches), " branches for migration: ", selectedBranches))
 
 	// Step 3: Find the most recent commit from origin/main
 	mostRecentMainCommit := findMostRecentMainCommit(selectedBranches)
-	slog.Debug(fmt.Sprintf("Most recent origin/main commit: %s", mostRecentMainCommit))
+	slog.Debug(fmt.Sprint("Most recent origin/main commit: ", mostRecentMainCommit))
 
 	// Step 4: Process each selected branch
 	var results []migrationResult
@@ -78,7 +78,7 @@ func executeMigrate() {
 
 	// Switch to main branch
 	mainBranch := gitutil.GetLocalMainBranchOrDie()
-	slog.Info(fmt.Sprintf("Switching to branch %s", mainBranch))
+	slog.Info(fmt.Sprint("Switching to branch ", mainBranch))
 	util.ExecuteOrDie(util.ExecuteOptions{}, "git", "checkout", mainBranch)
 
 	// Step 5: Report summary of migrated branches
@@ -87,16 +87,31 @@ func executeMigrate() {
 
 // processBranch handles the migration of a single branch
 func processBranch(branch string, baseCommit string) migrationResult {
-	slog.Info(fmt.Sprintf("Processing branch: %s", branch))
+	slog.Info(fmt.Sprint("Processing branch: ", branch))
 
 	// Step 4f: Check if branch has a PR - skip if so
 	mergedPR := gitutil.GetMergedPR(branch)
 	if mergedPR != nil {
-		slog.Warn(fmt.Sprintf("Branch %s has merged PR #%s: %s - skipping migration", branch, mergedPR.Number, mergedPR.Title))
+		slog.Warn(fmt.Sprint("Branch ", branch, " has merged PR #", mergedPR.Number, ": ", mergedPR.Title, " - skipping migration"))
 		return migrationResult{
 			branchName: branch,
 			success:    false,
-			reason:     fmt.Sprintf("already merged (PR #%s)", mergedPR.Number),
+			reason:     fmt.Sprint("already merged (PR #", mergedPR.Number, ")"),
+			numCommits: 0,
+		}
+	}
+
+	// Step 4c: Check if branch has an unmerged PR before modifying git state
+	pr := gitutil.GetUnmergedPR(branch)
+	if pr != nil {
+		// Step 4d: Handle branch with unmerged PR
+		// Branches with unmerged PRs are skipped because migrating them would create a new branch
+		// name (from the template) that doesn't match the existing PR's branch.
+		slog.Warn(fmt.Sprint("Branch ", branch, " has an unmerged PR #", pr.Number, ": ", pr.Title, " - skipping migration"))
+		return migrationResult{
+			branchName: branch,
+			success:    false,
+			reason:     fmt.Sprint("Unmerged PR (#", pr.Number, ")"),
 			numCommits: 0,
 		}
 	}
@@ -107,13 +122,13 @@ func processBranch(branch string, baseCommit string) migrationResult {
 
 	// Get commits ahead of base
 	commitsAhead := getCommitsAhead(baseCommit, "HEAD")
-	slog.Debug(fmt.Sprintf("Found %d commits ahead of main for branch %s", len(commitsAhead), branch))
+	slog.Debug(fmt.Sprint("Found ", len(commitsAhead), " commits ahead of main for branch ", branch))
 	for _, commit := range commitsAhead {
-		slog.Debug(fmt.Sprintf("  - %s", commit))
+		slog.Debug(fmt.Sprint("  - ", commit))
 	}
 
 	if len(commitsAhead) == 0 {
-		slog.Info(fmt.Sprintf("Branch %s has no commits ahead of main - skipping", branch))
+		slog.Info(fmt.Sprint("Branch ", branch, " has no commits ahead of main - skipping"))
 		return migrationResult{
 			branchName: branch,
 			success:    false,
@@ -122,23 +137,8 @@ func processBranch(branch string, baseCommit string) migrationResult {
 		}
 	}
 
-	// Step 4c: Check if branch has an unmerged PR
-	pr := gitutil.GetUnmergedPR(branch)
-	if pr != nil {
-		// Step 4d: Handle branch with unmerged PR
-		// Branches with unmerged PRs are skipped because migrating them would create a new branch
-		// name (from the template) that doesn't match the existing PR's branch.
-		slog.Warn(fmt.Sprintf("Branch %s has an unmerged PR #%s: %s - skipping migration", branch, pr.Number, pr.Title))
-		return migrationResult{
-			branchName: branch,
-			success:    false,
-			reason:     fmt.Sprintf("Unmerged PR (#%s)", pr.Number),
-			numCommits: 0,
-		}
-	} else {
-		// Step 4e: Handle branch without PR
-		return handleBranchWithoutPR(branch, baseCommit, commitsAhead)
-	}
+	// Step 4e: Handle branch without PR
+	return handleBranchWithoutPR(branch, baseCommit, commitsAhead)
 }
 
 // rebaseBranch rebases the current branch onto baseCommit, handling errors appropriately
@@ -148,7 +148,7 @@ func rebaseBranch(branch string, baseCommit string) {
 	gitutil.RebaseAndSkipAllEmptyOrDie(
 		util.ExecuteOptions{Io: util.StdIo{Out: appConfig.Io.Out, In: nil, Err: appConfig.Io.Err}},
 		baseCommit)
-	slog.Info(fmt.Sprintf("Successfully rebased branch: %s", branch))
+	slog.Info(fmt.Sprint("Successfully rebased branch: ", branch))
 }
 
 // itemWithTimestamp associates a name with a timestamp for sorting purposes
@@ -202,7 +202,7 @@ func findUserBranches() []string {
 		result[i] = b.name
 	}
 
-	slog.Info(fmt.Sprintf("Found %d branches with your commits", len(result)))
+	slog.Info(fmt.Sprint("Found ", len(result), " branches with your commits"))
 	return result
 }
 
@@ -229,7 +229,7 @@ func filterBranchesWithUserCommits(allBranches []string, mainBranch string, user
 			continue
 		}
 
-		slog.Debug(fmt.Sprintf("Found branch %s with user commits (timestamp: %s)", branch, strings.TrimSpace(logOutput)))
+		slog.Debug(fmt.Sprint("Found branch ", branch, " with user commits (timestamp: ", strings.TrimSpace(logOutput), ")"))
 		branchesWithTimestamps = append(branchesWithTimestamps, itemWithTimestamp{
 			name:      branch,
 			timestamp: timestamp,
@@ -285,7 +285,7 @@ func computeDisabledBranches(branches []string) map[int]bool {
 	slog.Info("Fetching commits from main for branch filtering...")
 	mainBranch := gitutil.GetLocalMainBranchOrDie()
 	mainCommits := templates.GetNewCommits(mainBranch, "")
-	slog.Info(fmt.Sprintf("Found %d commits on main for branch filtering", len(mainCommits)))
+	slog.Info(fmt.Sprint("Found ", len(mainCommits), " commits on main for branch filtering"))
 
 	branchesOnMain := make(map[string]bool)
 	for _, commit := range mainCommits {
@@ -299,7 +299,7 @@ func computeDisabledBranches(branches []string) map[int]bool {
 	for i, branch := range branches {
 		if branchesOnMain[branch] {
 			disabledBranches[i] = true
-			slog.Info(fmt.Sprintf("Branch %s already exists on main - will be disabled", branch))
+			slog.Info(fmt.Sprint("Branch ", branch, " already exists on main - will be disabled"))
 		}
 	}
 	return disabledBranches
@@ -318,7 +318,7 @@ func findMostRecentMainCommit(branches []string) string {
 	// For each branch, find its merge-base with origin/main
 	for _, branch := range allBranches {
 		mergeBase := gitutil.FirstOriginMainCommit(branch)
-		slog.Debug(fmt.Sprintf("Merge-base for %s with origin/main: %s", branch, mergeBase))
+		slog.Debug(fmt.Sprint("Merge-base for ", branch, " with origin/main: ", mergeBase))
 
 		// Get the timestamp of this commit
 		timestampStr := util.ExecuteOrDie(util.ExecuteOptions{}, "git", "log", "-1", "--format=%ct", mergeBase)
@@ -372,19 +372,19 @@ func promptForInput(prompt string) string {
 		return strings.TrimSpace(scanner.Text())
 	}
 	if err := scanner.Err(); err != nil {
-		panic(fmt.Sprintf("Failed to read input: %s", err.Error()))
+		panic(fmt.Sprint("Failed to read input: ", err.Error()))
 	}
 	return ""
 }
 
 // handleBranchWithoutPR handles step 4e: migration of a branch that doesn't have a PR.
 func handleBranchWithoutPR(branch string, baseCommit string, commitsAhead []string) migrationResult {
-	slog.Info(fmt.Sprintf("Branch %s does not have an unmerged PR", branch))
+	slog.Info(fmt.Sprint("Branch ", branch, " does not have an unmerged PR"))
 
 	// Prompt user for the eventual PR name
 	prName := promptForInput("What should the PR be named when it is eventually created")
 	if prName == "" {
-		slog.Info(fmt.Sprintf("No PR name provided, skipping branch %s", branch))
+		slog.Info(fmt.Sprint("No PR name provided, skipping branch ", branch))
 		return migrationResult{
 			branchName: branch,
 			success:    false,
@@ -402,7 +402,7 @@ func handleBranchWithoutPR(branch string, baseCommit string, commitsAhead []stri
 	// Rename the first commit to match the eventual PR title
 	firstCommit := commitsAhead[0]
 	renameCommitOnBranch(branch, firstCommit, prName)
-	slog.Info(fmt.Sprintf("Renamed first commit to: %s", prName))
+	slog.Info(fmt.Sprint("Renamed first commit to: ", prName))
 
 	// Rename remaining commits with prefix if provided
 	if commitPrefix != "" && len(commitsAhead) > 1 {
@@ -411,16 +411,16 @@ func handleBranchWithoutPR(branch string, baseCommit string, commitsAhead []stri
 
 	// Get the final list of commits in chronological order (oldest first)
 	finalCommits := getCommitsAhead(baseCommit, branch)
-	slog.Info(fmt.Sprintf("Final commits to cherry-pick (in order): %d commits", len(finalCommits)))
+	slog.Info(fmt.Sprint("Final commits to cherry-pick (in order): ", len(finalCommits), " commits"))
 	for i, commit := range finalCommits {
-		slog.Debug(fmt.Sprintf("  %d. %s: %s", i+1, commit, getCommitSubject(commit)))
+		slog.Debug(fmt.Sprint("  ", i+1, ". ", commit, ": ", getCommitSubject(commit)))
 	}
 
 	// Cherry-pick each commit onto local main branch IN ORDER (oldest to newest)
 	mainBranch := gitutil.GetLocalMainBranchOrDie()
 	util.ExecuteOrDie(util.ExecuteOptions{}, "git", "checkout", mainBranch)
 
-	slog.Info(fmt.Sprintf("Cherry-picking %d commits to %s (oldest to newest)", len(finalCommits), mainBranch))
+	slog.Info(fmt.Sprint("Cherry-picking ", len(finalCommits), " commits to ", mainBranch, " (oldest to newest)"))
 	gitutil.CherryPickAndSkipAllEmpty("", finalCommits)
 
 	return migrationResult{
@@ -479,7 +479,7 @@ func prefixRemainingCommits(branch string, baseCommit string, commitPrefix strin
 		oldSubject := getCommitSubject(commit)
 		newSubject := commitPrefix + " " + oldSubject
 		renameCommitOnBranch(branch, commit, newSubject)
-		slog.Info(fmt.Sprintf("Renamed commit to: %s", newSubject))
+		slog.Info(fmt.Sprint("Renamed commit to: ", newSubject))
 
 		// Get updated commit list after each rename since hashes change
 		currentCommits = getCommitsAhead(baseCommit, branch)

commands/command_migrate_test.go

@@ -426,7 +426,7 @@ func TestGetMergedPR_WithMergedPR(t *testing.T) {
 	testutil.AddCommit("feature 1 commit", "feature1.txt")
 
 	// Mock the gh pr list response to simulate a merged PR
-	testExecutor.SetResponse("456|Implement feature|MERGED", nil,
+	testExecutor.SetResponse("456"+gitutil.GhDelim+"Implement feature"+gitutil.GhDelim+"MERGED", nil,
 		"gh", "pr", "list", "--head", "feature-1", "--state", "merged",
 		"--json", "number,title,state", "--jq", util.MatchAnyRemainingArgs)
 
@@ -478,7 +478,7 @@ func TestSdMigrate_SkipsBranchWithMergedPR(t *testing.T) {
 	util.ExecuteOrDie(util.ExecuteOptions{}, "git", "checkout", gitutil.GetLocalMainBranchOrDie())
 
 	// Mock the gh pr list response to simulate a merged PR
-	testExecutor.SetResponse("789|Already merged feature|MERGED", nil,
+	testExecutor.SetResponse("789"+gitutil.GhDelim+"Already merged feature"+gitutil.GhDelim+"MERGED", nil,
 		"gh", "pr", "list", "--head", "feature-1", "--state", "merged",
 		"--json", "number,title,state", "--jq", util.MatchAnyRemainingArgs)
 

commands/command_rebase_main.go

@@ -65,9 +65,9 @@ func rebaseMain() {
 
 	var confirmedClosedCommits []templates.GitLog
 	if len(closedCommits) > 0 {
-		slog.Info(fmt.Sprintf("Found %d commits from closed (not merged) PRs:", len(closedCommits)))
+		slog.Info(fmt.Sprint("Found ", len(closedCommits), " commits from closed (not merged) PRs:"))
 		for _, closedCommit := range closedCommits {
-			slog.Info(fmt.Sprintf("  - %s: %s", closedCommit.Branch, closedCommit.Subject))
+			slog.Info(fmt.Sprint("  - ", closedCommit.Branch, ": ", closedCommit.Subject))
 		}
 		if interactive.Confirm("Do you want to drop these closed PR commits and delete their local branches?", false) {
 			confirmedClosedCommits = closedCommits
@@ -165,7 +165,7 @@ func getBranchesByPRState(mergedState bool) []string {
 	for _, branchRawLine := range branchesRawLines {
 		fields := strings.Fields(branchRawLine)
 		if len(fields) != 2 {
-			break
+			continue
 		}
 		// Validate refs from GitHub API before passing to git commands.
 		util.RequireGitRef(fields[0])

gitutil/gh_checks.go

@@ -112,6 +112,7 @@ func getMinChecks() int {
 			return numChecks
 		})
 		if len(allNumChecks) == 0 {
+			cache.minChecks = DefaultMinChecks
 			return
 		}
 

gitutil/gh_pr_info.go

@@ -22,37 +22,39 @@ type PrInfo struct {
 // Returns the PR information if found, nil otherwise.
 func GetMergedPR(branchName string) *PrInfo {
 	// Check for merged PRs with this branch as the head
-	slog.Debug(fmt.Sprintf("Checking for merged PR with head branch: %s", branchName))
+	slog.Debug(fmt.Sprint("Checking for merged PR with head branch: ", branchName))
 	output := util.ExecuteOrDieTrimmed(
 		util.ExecuteOptions{Retries: GhRetries},
 		"gh", "pr", "list",
 		"--head", branchName,
 		"--state", "merged",
 		"--json", "number,title,state",
-		"--jq", ".[0] | \"\\(.number)|\\(.title)|\\(.state)\"",
+		"--jq", ".[0] | \"\\(.number)"+GhDelim+"\\(.title)"+GhDelim+"\\(.state)\"",
 	)
 
-	slog.Debug(fmt.Sprintf("gh pr list output for branch %s: '%s'", branchName, output))
+	slog.Debug(fmt.Sprint("gh pr list output for branch ", branchName, ": '", output, "'"))
 
-	if output == "" || output == "null" || output == "||" || output == "null|null|null" {
-		slog.Debug(fmt.Sprintf("No merged PR found for branch %s", branchName))
+	nullOutput := GhDelim + GhDelim
+	nullNullOutput := "null" + GhDelim + "null" + GhDelim + "null"
+	if output == "" || output == "null" || output == nullOutput || output == nullNullOutput {
+		slog.Debug(fmt.Sprint("No merged PR found for branch ", branchName))
 		return nil
 	}
 
-	// Parse the output: "number|title|state"
-	parts := strings.SplitN(output, "|", 3)
+	// Parse the output: "number<delim>title<delim>state"
+	parts := strings.SplitN(output, GhDelim, 4)
 	if len(parts) != 3 {
-		slog.Warn(fmt.Sprintf("Unexpected PR output format for branch %s: %s", branchName, output))
+		slog.Warn(fmt.Sprint("Unexpected PR output format for branch ", branchName, ": ", output))
 		return nil
 	}
 
 	// Check if any part is empty or "null" (which means the PR data was incomplete/missing)
 	if parts[0] == "" || parts[0] == "null" || parts[1] == "" || parts[1] == "null" || parts[2] == "" || parts[2] == "null" {
-		slog.Debug(fmt.Sprintf("No merged PR found for branch %s (empty or null PR data)", branchName))
+		slog.Debug(fmt.Sprint("No merged PR found for branch ", branchName, " (empty or null PR data)"))
 		return nil
 	}
 
-	slog.Debug(fmt.Sprintf("Found merged PR for branch %s: #%s - %s (%s)", branchName, parts[0], parts[1], parts[2]))
+	slog.Debug(fmt.Sprint("Found merged PR for branch ", branchName, ": #", parts[0], " - ", parts[1], " (", parts[2], ")"))
 
 	return &PrInfo{
 		Number: parts[0],