docs: @Override
      public void execute() throws MojoExecutionException, MojoFailureException {
          validateConfiguration();
  
          try {
              // set git flow configuration
              initGitFlowConfig();
  
              // check uncommitted changes
              checkUncommittedChanges();
  
              String branchName = gitFlowConfig.getProductionBranch();
  
              // find support branches
              final String supportBranchesStr = gitFindBranches(gitFlowConfig.getSupportBranchPrefix(), false);
  
              final String[] supportBranches;
              if (StringUtils.isNotBlank(supportBranchesStr)) {
                  supportBranches = supportBranchesStr.split("\\r?\\n");
              } else {
                  supportBranches = null;
              }
  
              if (settings.isInteractiveMode()) {
                  if (supportBranches != null && supportBranches.length > 0) {
                      String[] branches = new String[supportBranches.length + 1];
                      for (int i = 0; i < supportBranches.length; i++) {
                          branches[i] = supportBranches[i];
                      }
                      // add production branch to the list
                      branches[supportBranches.length] = gitFlowConfig
                              .getProductionBranch();
  
                      List<String> numberedList = new ArrayList<String>();
                      StringBuilder str = new StringBuilder("Branches:")
                              .append(LS);
                      for (int i = 0; i < branches.length; i++) {
                          str.append((i + 1) + ". " + branches[i] + LS);
                          numberedList.add(String.valueOf(i + 1));
                      }
                      str.append("Choose branch to hotfix");
  
                      String branchNumber = null;
                      try {
                          while (StringUtils.isBlank(branchNumber)) {
                              branchNumber = prompter.prompt(str.toString(),
                                      numberedList);
                          }
                      } catch (PrompterException e) {
                          throw new MojoFailureException("hotfix-start", e);
                      }
  
                      if (branchNumber != null) {
                          int num = Integer.parseInt(branchNumber);
                          branchName = branches[num - 1];
                      }
  
                      if (StringUtils.isBlank(branchName)) {
                          throw new MojoFailureException("Branch name is blank.");
                      }
                  }
              } else if (StringUtils.isNotBlank(fromBranch)) {
                  if (fromBranch.equals(gitFlowConfig.getProductionBranch()) || contains(supportBranches, fromBranch)) {
                      branchName = fromBranch;
                  } else {
                      throw new MojoFailureException("The fromBranch is not production or support branch.");
                  }
              }
  
              // need to be in master to get correct project version
              // git checkout master
              gitCheckout(branchName);
  
              // fetch and check remote
              if (fetchRemote) {
                  gitFetchRemoteAndCompare(branchName);
              }
  
              // get current project version from pom
              final String currentVersion = getCurrentProjectVersion();
  
              // get default hotfix version
              final String defaultVersion = new GitFlowVersionInfo(currentVersion)
                      .hotfixVersion(tychoBuild);
  
              if (defaultVersion == null) {
                  throw new MojoFailureException(
                          "Cannot get default project version.");
              }
  
              String version = null;
              if (settings.isInteractiveMode()) {
                  try {
                      while (version == null) {
                          version = prompter
                                  .prompt("What is the hotfix version? ["
                                          + defaultVersion + "]");
  
                          if (!"".equals(version)
                                  && (!GitFlowVersionInfo.isValidVersion(version)
                                          || !validBranchName(version))) {
                              getLog().info("The version is not valid.");
                              version = null;
                          }
                      }
                  } catch (PrompterException e) {
                      throw new MojoFailureException("hotfix-start", e);
                  }
              } else {
                  if (StringUtils.isNotBlank(hotfixVersion)
                          && (!GitFlowVersionInfo.isValidVersion(hotfixVersion)
                                  || !validBranchName(hotfixVersion))) {
                      throw new MojoFailureException("The hotfix version '"
                              + hotfixVersion + "' is not valid.");
                  } else {
                      version = hotfixVersion;
                  }
              }
  
              if (StringUtils.isBlank(version)) {
                  getLog().info("Version is blank. Using default version.");
                  version = defaultVersion;
              }
  
              // to finish hotfix on support branch
              String branchVersionPart = version.replace('/', '_');
  
              String hotfixBranchName = gitFlowConfig.getHotfixBranchPrefix()
                      + branchVersionPart;
              if (!gitFlowConfig.getProductionBranch().equals(branchName)) {
                  hotfixBranchName = gitFlowConfig.getHotfixBranchPrefix()
                          + branchName + "/" + branchVersionPart;
              }
  
              // git for-each-ref refs/heads/hotfix/...
              final boolean hotfixBranchExists = gitCheckBranchExists(
                      hotfixBranchName);
  
              if (hotfixBranchExists) {
                  throw new MojoFailureException(
                          "Hotfix branch with that name already exists. Cannot start hotfix.");
              }
  
              // git checkout -b hotfix/... master
              gitCreateAndCheckout(hotfixBranchName, branchName);
  
              // execute if version changed
              if (!version.equals(currentVersion)) {
                  String projectVersion = version;
                  if (useSnapshotInHotfix && !ArtifactUtils.isSnapshot(version)) {
                      projectVersion = version + "-" + Artifact.SNAPSHOT_VERSION;
                  }
  
                  if (useSnapshotInHotfix && mavenSession.getUserProperties().get("useSnapshotInHotfix") != null) {
                      getLog().warn(
                              "The useSnapshotInHotfix parameter is set from the command line. Don't forget to use it in the finish goal as well."
                                      + " It is better to define it in the project's pom file.");
                  }
  
                  // mvn versions:set -DnewVersion=... -DgenerateBackupPoms=false
                  mvnSetVersions(projectVersion);
  
                  Map<String, String> properties = new HashMap<String, String>();
                  properties.put("version", projectVersion);
  
                  // git commit -a -m updating versions for hotfix
                  gitCommit(commitMessages.getHotfixStartMessage(), properties);
              }
  
              if (installProject) {
                  // mvn clean install
                  mvnCleanInstall();
              }
  
              if (pushRemote) {
                  gitPush(hotfixBranchName, false);
              }
          } catch (CommandLineException e) {
              throw new MojoFailureException("hotfix-start", e);
          } catch (VersionParseException e) {
              throw new MojoFailureException("hotfix-start", e);
          }
      }