add --force flag to alpha update

This commit adds the --force flag to the alpha update command.
It also adds 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,46 @@ 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 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).                                                                       |
 | `-h, --help`        | Show help for this command.                                                                                                                                    |
 
+## Using the `--force` flag
+
+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.
+
+## 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

@@ -39,6 +39,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
@@ -335,8 +337,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

@@ -50,9 +50,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
@@ -64,6 +63,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 {
@@ -93,5 +95,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
 }