add --force flag to alpha update command

This commit adds the --force flag to the alpha update command.
It also adds e2e tests and documentation for the flag.
The --force flag makes it possible to run the alpha update command in CI workflows.

Author: vitorfloriano

docs/book/src/reference/commands/alpha_update.md

@@ -61,6 +61,12 @@ kubebuilder alpha update \
   --from-branch=main
 ```
 
+Force update even with merge conflicts:
+
+```sh
+kubebuilder alpha update --force
+```
+
 <aside class="note warning">
 <h1>You might need to upgrade your project first</h1>
 
@@ -81,8 +87,49 @@ Once updated, you can use `kubebuilder alpha update` for future upgrades.
 | `--from-version`    | **Required for projects initialized with versions earlier than v4.6.0.** Kubebuilder version your project was created with. If unset, uses the `PROJECT` file. |
 | `--to-version`      | Version to upgrade to. Defaults to the latest version.                                                                                                         |
 | `--from-branch`     | Git branch that contains your current project code. Defaults to `main`.                                                                                        |
+| `--force`           | Force update even with merge conflicts by committing conflict markers. See warning below.                                                                      |
 | `-h, --help`        | Show help for this command.                                                                                                                                    |
 
+<aside class="note warning">
+<h1>Using --force flag</h1>
+
+When using the `--force` flag, merge conflicts will be committed with conflict markers in the `tmp-kb-update-merge` branch. 
+You should carefully review and resolve these conflicts before merging into your main branch.
+
+After resolving conflicts, run the following command to ensure manifests and generated files are up to date:
+```sh
+make manifests generate fmt vet lint-fix
+```
+
+You might want to run `make all`, ensure that all tests are passing, and thoroughly validate the final result before committing and pushing a pull request to update your project from the `tmp-kb-update-merge` branch.
+
+</aside>
+
+## Handling Merge Conflicts
+
+If conflicts occur during a merge, Git will stop the process and leave the merge branch in a conflicted state for manual resolution.
+
+To proceed with the merge despite conflicts, you can use the `--force` option. This is useful in automated environments, such as CI pipelines or cron jobs, where you want to create a pull request with the changes - even if conflicts are present.
+
+```
+kubebuilder alpha update --force
+```
+The resulting commit will include conflict markers in the affected files:
+
+```
+<<<<<<< HEAD
+Your changes
+=======
+Incoming changes
+>>>>>>> branch-name
+```
+
+The commit message will indicate that conflicts are present and need to be resolved manually.
+
+<aside>
+Note: This approach is typically used in automation workflows where conflict markers are later addressed by a human, or where preserving the conflicting changes is acceptable for follow-up processing.
+</aside>
+
 <aside class="note warning">
 <h1>Projects generated with </h1>
 

pkg/cli/alpha/internal/update/update.go

@@ -38,6 +38,8 @@ type Update struct {
 	ToVersion string
 	// FromBranch stores the branch to update from, e.g., "main".
 	FromBranch string
+	// Force commits the update changes even with merge conflicts
+	Force bool
 
 	// UpdateBranches
 	AncestorBranch string
@@ -334,8 +336,15 @@ func (opts *Update) mergeOriginalToUpgrade() error {
 		var exitErr *exec.ExitError
 		// If the merge has an error that is not a conflict, return an error 2
 		if errors.As(err, &exitErr) && exitErr.ExitCode() == 1 {
-			log.Warn("Merge completed with conflicts. Manual resolution required.")
 			hasConflicts = true
+			if !opts.Force {
+				log.Warn("Merge stopped due to conflicts. Manual resolution is required.")
+				log.Warn("After resolving the conflicts, run the following command:")
+				log.Warn("    make manifests generate fmt vet lint-fix")
+				log.Warn("This ensures manifests and generated files are up to date, and the project layout remains consistent.")
+				return fmt.Errorf("merge stopped due to conflicts")
+			}
+			log.Warn("Merge completed with conflicts. Conflict markers will be committed.")
 		} else {
 			return fmt.Errorf("merge failed unexpectedly: %w", err)
 		}

pkg/cli/alpha/update.go

@@ -49,9 +49,8 @@ The process uses Git branches:
   - upgrade: scaffold from the target version
   - merge: result of the 3-way merge
 
-If conflicts occur during the merge, resolve them manually in the 'merge' branch. 
-Once resolved, commit and push it as a pull request. This branch will contain the 
-final upgraded project with the latest Kubebuilder layout and your custom code.
+If conflicts occur during the merge, the command will stop and leave the merge branch for manual resolution.
+Use --force to commit conflicts with markers instead. 
 
 Examples:
   # Update from the version specified in the PROJECT file to the latest release
@@ -63,6 +62,9 @@ Examples:
   # Update from a specific version to an specific release
   kubebuilder alpha update --from-version v4.5.0 --to-version v4.7.0	
 
+  # Force update even with merge conflicts (commit conflict markers)
+  kubebuilder alpha update --force
+
 `,
 
 		PreRunE: func(_ *cobra.Command, _ []string) error {
@@ -92,5 +94,9 @@ Examples:
 	updateCmd.Flags().StringVar(&opts.FromBranch, "from-branch", "",
 		"Git branch to use as current state of the project for the update.")
 
+	updateCmd.Flags().BoolVar(&opts.Force, "force", false,
+		"Force the update even if conflicts occur. Conflicted files will include conflict markers, and a "+
+			"commit will be created automatically. Ideal for automation (e.g., cronjobs, CI).")
+
 	return updateCmd
 }

test/e2e/alphaupdate/update_test.go

@@ -105,6 +105,45 @@ var _ = Describe("kubebuilder", func() {
 			By("validating custom code preservation")
 			validateCustomCodePreservation(mockProjectDir)
 		})
+
+		It("should stop on merge conflicts when --force is not used", func() {
+			By("creating mock project with kubebuilder v4.5.2")
+			createMockProject(mockProjectDir, binFromVersionPath)
+
+			By("initializing git repository and committing mock project")
+			initializeGitRepo(mockProjectDir)
+
+			By("running alpha update without --force flag")
+			cmd := exec.Command(kbc.BinaryName, "alpha", "update",
+				"--from-version", fromVersion, "--to-version", toVersion, "--from-branch", "main")
+			cmd.Dir = mockProjectDir
+			output, err := cmd.CombinedOutput()
+
+			By("expecting the command to fail due to merge conflicts")
+			Expect(err).To(HaveOccurred())
+			Expect(string(output)).To(ContainSubstring("Merge stopped due to conflicts"))
+			Expect(string(output)).To(ContainSubstring("merge stopped due to conflicts"))
+		})
+
+		It("should commit with conflict markers when --force is used", func() {
+			By("creating mock project with kubebuilder v4.5.2")
+			createMockProject(mockProjectDir, binFromVersionPath)
+
+			By("initializing git repository and committing mock project")
+			initializeGitRepo(mockProjectDir)
+
+			By("running alpha update with --force flag")
+			cmd := exec.Command(kbc.BinaryName, "alpha", "update",
+				"--from-version", fromVersion, "--to-version", toVersion, "--from-branch", "main", "--force")
+			cmd.Dir = mockProjectDir
+			output, err := cmd.CombinedOutput()
+
+			By("expecting the command to succeed despite conflicts")
+			Expect(err).NotTo(HaveOccurred(), fmt.Sprintf("Alpha update with --force failed: %s", string(output)))
+
+			By("validating that conflict markers are present in the merged files")
+			validateConflictMarkers(mockProjectDir)
+		})
 	})
 })
 
@@ -283,3 +322,20 @@ func validateCustomCodePreservation(projectDir string) {
 	Expect(string(content)).To(ContainSubstring("log.Info(\"Reconciling TestOperator\")"))
 	Expect(string(content)).To(ContainSubstring("log.Info(\"TestOperator size\", \"size\", testOperator.Spec.Size)"))
 }
+
+func validateConflictMarkers(projectDir string) {
+	// Use git to check for conflict markers across the entire project
+	cmd := exec.Command("git", "grep", "-l", "^<<<<<<<\\|^=======\\|^>>>>>>>", ".")
+	cmd.Dir = projectDir
+	output, err := cmd.CombinedOutput()
+
+	// If git grep finds conflict markers, it returns exit code 0
+	// If no conflict markers are found, it returns exit code 1
+	if err == nil {
+		// Conflict markers found - this is expected
+		Expect(output).ToNot(BeEmpty(), "Expected conflict markers in merged files")
+	} else {
+		// No conflict markers found
+		Expect(false).To(BeTrue(), "Expected conflict markers in merged files but none were found")
+	}
+}