pindo 5.13.7 → 5.13.10

data/lib/pindo/module/build/git_repo_helper.rb

@@ -1,13 +1,25 @@
 require 'singleton'
-require 'pindo/base/githelper'
+require 'pindo/base/git_handler'
 require 'pindo/base/executable'
-require 'pindo/base/pindocontext'
 require 'highline/import'
 
 module Pindo
+  # 版本号增加类型常量（与 GitOptions::VERSION_INCREASE_TYPES 一致）
+  module VersionIncreaseType
+    MAIN = :main       # 大版本号增加1 (x.0.0)
+    MINI = :mini       # 小版本号增加1 (0.x.0)
+    PATCH = :patch     # patch版本号增加1 (0.0.x)
+  end
+
+  # 创建Tag类型常量（与 GitOptions::CREATE_TAG_TYPES 一致）
+  module CreateTagType
+    NEW = :new           # 创建新的tag，新的版本号
+    RECREATE = :recreate # 重新创建当前版本号
+    NONE = :none         # 不创建版本号
+  end
+
   class GitRepoHelper
     include Singleton
-    include Pindo::Githelper
 
     attr_accessor :temp_tag_decision
 
@@ -17,57 +29,11 @@ module Pindo
       end
     end
 
-    # 主入口函数 - 创建并推送 Git 标签
-    # @param project_dir [String] 项目目录
-    # @param mode [String] 版本号增加模式 (major/minor/patch)
-    # @param force_retag [Boolean] 是否强制重新打tag
-    # @param custom_tag [String] 自定义tag版本号
-    # @param release_branch [String] 发布分支名称，默认为 'master'
-    def create_and_push_tag(project_dir:, mode: 'minor', force_retag: false, custom_tag: nil, release_branch: 'master')
-      puts project_dir
-
-      # 1. 验证 Git 仓库
-      unless is_git_directory?(local_repo_dir: project_dir)
-        raise Informative, "当前目录不是git仓库，请在git仓库目录下执行此命令"
-      end
-
-      # 获取git仓库根目录
-      root_dir = git_root_directory(local_repo_dir: project_dir)
-      if root_dir.nil?
-        raise Informative, "无法获取git仓库根目录"
-      end
-
-      # 2. 处理未提交的文件
-      process_need_add_files(project_dir: root_dir)
-
-      # 3. 获取当前分支
-      current_branch = git!(%W(-C #{root_dir} rev-parse --abbrev-ref HEAD)).strip
-      coding_branch = current_branch
-
-      # 4. 合并到发布分支
-      Funlog.instance.fancyinfo_start("开始合并到#{release_branch}分支")
-      merge_to_release_branch(
-        project_dir: root_dir,
-        release_branch: release_branch,
-        coding_branch: coding_branch
-      )
-
-      # 5. 添加版本标签并返回 tag 名称
-      new_tag = add_release_tag(
-        project_dir: root_dir,
-        increment_mode: mode,
-        force_retag: force_retag,
-        custom_tag: custom_tag
-      )
-
-      new_tag
-    end
-
     # 检查并安装 git-cliff
     # @param project_path [String] 项目路径
     def check_check_and_install_cliff(project_path)
-      if is_git_directory?(local_repo_dir: project_path)
-        current_git_root_path = git_root_directory(local_repo_dir: project_path)
+      if Pindo::GitHandler.is_git_directory?(local_repo_dir: project_path)
+        current_git_root_path = Pindo::GitHandler.git_root_directory(local_repo_dir: project_path)
         unless File.exist?(File.join(current_git_root_path, 'cliff.toml'))
           add_git_cliffconfig(current_git_root_path)
         end
@@ -84,10 +50,59 @@ module Pindo
       end
     end
 
-    # 写入 .gitignore 文件
+    # 添加 git-cliff 配置
+    # @param project_path [String] 项目路径
+    def add_git_cliffconfig(project_path)
+      temp_dir = Dir.pwd
+      Funlog.instance.fancyinfo_start("添加日志变更git-cliff配置...")
+      if Pindo::GitHandler.is_git_directory?(local_repo_dir: project_path)
+        current_git_root_path = Pindo::GitHandler.git_root_directory(local_repo_dir: project_path)
+        Dir.chdir(current_git_root_path)
+        pindo_common_dir = clone_pindo_common_config_repo(force_delete:false)
+        if File.exist?(File.join(pindo_common_dir, 'cliff.toml'))
+          FileUtils.cp_r(File.join(pindo_common_dir, 'cliff.toml'), File.join(current_git_root_path, 'cliff.toml'))
+        end
+        Funlog.instance.fancyinfo_update("仓库添加git-cliff配置")
+        # 不自动提交推送，因为后续会将 cliff.toml 和 .gitignore 一起提交
+        check_gitignore(current_git_root_path, auto_commit_push: false)
+        Funlog.instance.fancyinfo_update("仓库检查并添加.gitignore规则")
+        Dir.chdir(current_git_root_path)
+        current_branch = Pindo::GitHandler.git!(%W(-C #{current_git_root_path} rev-parse --abbrev-ref HEAD)).strip
+        Pindo::GitHandler.git!(%W(-C #{current_git_root_path} add cliff.toml))
+        # .gitignore 已由 check_gitignore 自动添加到暂存区，无需重复添加
+        commit_message = "docs: 添加日志变更配置".encode('UTF-8')
+        Pindo::GitHandler.git!(%W(-C #{current_git_root_path} commit -m #{commit_message}))
+        Pindo::GitHandler.git!(%W(-C #{current_git_root_path} push origin #{current_branch}))
+      else
+        Funlog.instance.fancyinfo_error("当前目录不是git仓库，请在git仓库根目录下执行此命令")
+        Dir.chdir(temp_dir)
+        return
+      end
+      Funlog.instance.fancyinfo_success("日志变更git-cliff配置完成!")
+      Dir.chdir(temp_dir)
+    end
+
+    # 安装 git-cliff
+    def install_gitcliff
+      puts "\n检查git-cliff命令是否安装"
+      begin
+        if !system('which git-cliff > /dev/null 2>&1')
+          system('bash -c "$(curl -fsSL https://gitee.com/goodtools/env/raw/master/gitcliff_install.sh)"')
+        end
+      rescue
+        Funlog.instance.fancyinfo_error("安装git-cliff出现错误")
+      end
+    end
+
+
+    # 检查并写入 .gitignore 文件（不会重复添加规则）
+    # 如果修改了文件，会自动执行 git add、commit 和 push
     # @param git_root_dir [String] Git 根目录
-    def write_gitignore(git_root_dir)
+    # @param auto_commit_push [Boolean] 是否自动提交并推送，默认 true
+    # @return [Boolean] 返回是否修改了 .gitignore 文件
+    def check_gitignore(git_root_dir, auto_commit_push: true)
       gitignore_path = File.join(git_root_dir, '.gitignore')
+      file_modified = false
 
       # 定义要添加的gitignore规则数组
       ignore_rules = [
@@ -110,6 +125,7 @@ module Pindo
         'Assets/Packages',
         'Assets/WebGLTemplates.meta',
         'Assets/WebGLTemplates/',
+        'JPSMedia',
         'Packages/packages-lock.json'
       ]
 
@@ -134,397 +150,260 @@ module Pindo
             f.puts(rule)
           end
         end
-      end
-    end
 
-    # 添加 git-cliff 配置
-    # @param project_path [String] 项目路径
-    def add_git_cliffconfig(project_path)
-      temp_dir = Dir.pwd
-      Funlog.instance.fancyinfo_start("添加日志变更git-cliff配置...")
-      if is_git_directory?(local_repo_dir: project_path)
-        current_git_root_path = git_root_directory(local_repo_dir: project_path)
-        Dir.chdir(current_git_root_path)
-        pindo_common_dir = clone_pindo_common_config_repo(force_delete:false)
-        if File.exist?(File.join(pindo_common_dir, 'cliff.toml'))
-          FileUtils.cp_r(File.join(pindo_common_dir, 'cliff.toml'), File.join(current_git_root_path, 'cliff.toml'))
+        # 标记文件已修改
+        file_modified = true
+
+        # 自动添加到 Git 暂存区、提交并推送
+        if Pindo::GitHandler.is_git_directory?(local_repo_dir: git_root_dir)
+          begin
+            # 1. 添加到暂存区
+            Pindo::GitHandler.git!(%W(-C #{git_root_dir} add .gitignore))
+            Funlog.instance.fancyinfo_success("已自动添加 .gitignore 到 Git 暂存区")
+
+            # 2. 如果需要，自动提交并推送
+            if auto_commit_push
+              # 获取当前分支
+              current_branch = Pindo::GitHandler.git!(%W(-C #{git_root_dir} rev-parse --abbrev-ref HEAD)).strip
+
+              # 提交
+              commit_message = "chore: 更新 .gitignore 规则"
+              Pindo::GitHandler.git!(%W(-C #{git_root_dir} commit -m #{commit_message}))
+              Funlog.instance.fancyinfo_success("已自动提交 .gitignore 更改")
+
+              # 推送到远程
+              Pindo::GitHandler.git!(%W(-C #{git_root_dir} push origin #{current_branch}))
+              Funlog.instance.fancyinfo_success("已自动推送 .gitignore 到远程仓库")
+            end
+          rescue => e
+            Funlog.instance.fancyinfo_error("Git 操作失败: #{e.message}")
+          end
         end
-        Funlog.instance.fancyinfo_update("仓库添加git-cliff配置")
-        write_gitignore(current_git_root_path)
-        Funlog.instance.fancyinfo_update("仓库添加.gitignore")
-        Dir.chdir(current_git_root_path)
-        current_branch = git!(%W(-C #{current_git_root_path} rev-parse --abbrev-ref HEAD)).strip
-        git!(%W(-C #{current_git_root_path} add cliff.toml))
-        git!(%W(-C #{current_git_root_path} add .gitignore))
-        commit_message = "docs: 添加日志变更配置".encode('UTF-8')
-        git!(%W(-C #{current_git_root_path} commit -m #{commit_message}))
-        git!(%W(-C #{current_git_root_path} push origin #{current_branch}))
-      else
-        Funlog.instance.fancyinfo_error("当前目录不是git仓库，请在git仓库根目录下执行此命令")
-        Dir.chdir(temp_dir)
-        return
       end
-      Funlog.instance.fancyinfo_success("日志变更git-cliff配置完成!")
-      Dir.chdir(temp_dir)
+
+      file_modified
     end
 
-    # 安装 git-cliff
-    def install_gitcliff
-      puts "\n检查git-cliff命令是否安装"
-      begin
-        if !system('which git-cliff > /dev/null 2>&1')
-          system('bash -c "$(curl -fsSL https://gitee.com/goodtools/env/raw/master/gitcliff_install.sh)"')
+# 从Git tag获取当前版本号
+    # @param project_dir [String] 项目目录路径
+    # @param tag_prefixes [Array<String>] 可能的tag前缀列表，默认为 ["v", "release", ""]
+    # @return [String] 版本号（例如：1.2.0），如果没有tag则返回0.0.1
+    def get_current_version_from_tag(project_dir: nil, tag_prefixes: nil)
+      raise ArgumentError, "项目目录不能为空" if project_dir.nil?
+
+      # 获取git根目录
+      git_root = Pindo::GitHandler.git_root_directory(local_repo_dir: project_dir)
+      return "0.0.1" unless git_root
+
+      # 如果传入的前缀为空或nil，使用默认值
+      prefixes = (tag_prefixes.nil? || tag_prefixes.empty?) ? ["v", "release", ""] : tag_prefixes
+
+      # 尝试不同的tag前缀
+      latest_tag = nil
+      matched_prefix = nil
+      prefixes.each do |prefix|
+        latest_tag = Pindo::GitHandler.get_latest_version_tag(project_dir: git_root, tag_prefix: prefix)
+        if latest_tag
+          matched_prefix = prefix
+          break
         end
-      rescue
-        Funlog.instance.fancyinfo_error("安装git-cliff出现错误")
       end
-    end
 
-    # 检查是否需要添加 Git 标签
-    # @param project_path [String] 项目路径
-    # @param auto_mode [Boolean] 是否自动模式
-    # @return [Array<Boolean, Array>] [是否需要添加tag, tag参数]
-    def check_is_need_add_tag?(project_path, auto_mode: false)
-      tag_action_parms = nil
-      is_need_add_tag = false
-
-      if is_git_directory?(local_repo_dir: project_path)
-        current_git_root_path = git_root_directory(local_repo_dir: project_path)
-        latest_tag = get_latest_version_tag(project_dir: current_git_root_path)
-
-        # 检查是否需要打 tag：
-        # 1. 最新 tag 不在 HEAD 上，或者
-        # 2. 仓库有未提交的更改
-        tag_not_at_head = !is_tag_at_head?(git_root_dir: current_git_root_path, tag_name: latest_tag)
-        has_uncommitted = has_uncommitted_changes?(git_root_dir: current_git_root_path)
-
-        if tag_not_at_head || has_uncommitted
-          # 提示用户需要打 tag 的原因
-          if has_uncommitted && !tag_not_at_head
-            puts "\n注意：仓库有未提交的更改，建议提交后再打 Tag"
-          end
-          # 检查环境变量
-          env_tag_decision = ENV['PINDO_TAG_DECISION']
-          if env_tag_decision && !env_tag_decision.empty?
-            case env_tag_decision.downcase
-            when 'new', 'new_tag', '1'
-              puts "\n环境变量指定：新增版本号,打新Tag"
-              puts
-              tag_action_parms = []
-              is_need_add_tag = true
-              # 保存到缓存
-              context = PindoContext.instance
-              decision = {
-                tag_action_parms: tag_action_parms,
-                is_need_add_tag: is_need_add_tag,
-                action: :new_tag,
-                description: "新增版本号,打新Tag"
-              }
-              context.set_selection(PindoContext::SelectionKey::TAG_DECISION, decision)
-              return is_need_add_tag, tag_action_parms
-            when 'retag', 'recreate', '2'
-              puts "\n环境变量指定：将上次的Tag删除重新打Tag"
-              puts
-              tag_action_parms = ['--retag']
-              is_need_add_tag = true
-              # 保存到缓存
-              context = PindoContext.instance
-              decision = {
-                tag_action_parms: tag_action_parms,
-                is_need_add_tag: is_need_add_tag,
-                action: :recreate_tag,
-                description: "将上次的Tag删除重新打Tag"
-              }
-              context.set_selection(PindoContext::SelectionKey::TAG_DECISION, decision)
-              return is_need_add_tag, tag_action_parms
-            when 'skip', 'no', 'none', '3'
-              puts "\n环境变量指定：不需要Tag继续编译"
-              puts
-              tag_action_parms = nil
-              is_need_add_tag = false
-              # 保存到缓存
-              context = PindoContext.instance
-              decision = {
-                tag_action_parms: tag_action_parms,
-                is_need_add_tag: is_need_add_tag,
-                action: :continue_without_tag,
-                description: "不需要Tag继续编译且上传"
-              }
-              context.set_selection(PindoContext::SelectionKey::TAG_DECISION, decision)
-              return is_need_add_tag, tag_action_parms
-            when 'exit', 'quit', '4'
-              Funlog.instance.fancyinfo_error("环境变量指定：终止退出编译!")
-              return false, nil
-            end
-          end
+      return "0.0.1" if latest_tag.nil?
 
-          if auto_mode
-            # 在自动化模式或没有交互式终端时，默认选择新增版本号打新Tag
-            puts "检测到当前代码没有打Tag，在自动模式下将自动新增版本号并打新Tag"
-            tag_action_parms = []
-            is_need_add_tag = true
-          else
-            # 检查是否已有用户选择
-            context = PindoContext.instance
-            # 优先从持久化缓存读取，如果没有则从内存临时缓存读取
-            cached_decision = context.get_selection(PindoContext::SelectionKey::TAG_DECISION)
-
-            # 只有当持久化缓存中确实不存在该键时，才从临时缓存读取
-            if cached_decision.nil? && !context.has_selection?(PindoContext::SelectionKey::TAG_DECISION)
-              # 从 GitRepoHelper 的临时缓存读取
-              cached_decision = self.temp_tag_decision
-            end
-
-            if cached_decision && cached_decision.is_a?(Hash)
-              # 使用之前的选择
-              puts "\n使用之前的选择：#{cached_decision[:description]}"
-              tag_action_parms = cached_decision[:tag_action_parms]
-              is_need_add_tag = cached_decision[:is_need_add_tag]
-
-              # 如果是退出选择，则返回
-              if cached_decision[:action] == :exit
-                Funlog.instance.fancyinfo_error("终止退出编译!")
-                return false, nil
-              end
-            else
-              # 第一次询问
-              cli = HighLine.new
-              selected_action = nil
-              selected_description = nil
-
-              menu_options = {
-                "新增版本号,打新Tag" => -> {
-                  tag_action_parms = []
-                  selected_action = :new_tag
-                  selected_description = "新增版本号,打新Tag"
-                  is_need_add_tag = true
-                  :new_tag
-                },
-                "将上次的Tag删除重新打Tag" => -> {
-                  tag_action_parms = []
-                  tag_action_parms << "--retag"
-                  selected_action = :recreate_tag
-                  selected_description = "将上次的Tag删除重新打Tag"
-                  is_need_add_tag = true
-                  :recreate_tag
-                },
-                "不需要Tag继续编译且上传，手动修改上传备注" => -> {
-                  puts ""
-                  tag_action_parms = nil
-                  selected_action = :continue_without_tag
-                  selected_description = "不需要Tag继续编译且上传"
-                  is_need_add_tag = false
-                  :continue_without_tag
-                },
-                "终止退出编译" => -> {
-                  tag_action_parms = nil
-                  selected_action = :exit
-                  selected_description = "终止退出编译"
-                  is_need_add_tag = false
-                  Funlog.instance.fancyinfo_error("终止退出编译!")
-                  :exit
-                }
-              }
-
-              result = cli.choose do |menu|
-                menu.header = "当前代码并没有打Tag,上传的Changelog需要Tag"
-                menu.prompt = "请选中打Tag的方式, 请输入选项(1/2/3...):"
-                menu_options.each do |option, action|
-                  menu.choice(option) { action.call }
-                end
-              end
-
-              # 如果选择退出，直接返回
-              return false, nil if selected_action == :exit
-
-              # 保存用户选择
-              # 只有选择"新增版本号,打新Tag"时才保存到持久化缓存
-              if selected_action == :new_tag
-                # 保存到持久化缓存（文件）
-                context.set_selection(PindoContext::SelectionKey::TAG_DECISION, {
-                  action: selected_action,
-                  description: selected_description,
-                  tag_action_parms: tag_action_parms,
-                  is_need_add_tag: is_need_add_tag
-                })
-                # 清除临时缓存
-                self.temp_tag_decision = nil
-              else
-                # 不清空持久化缓存（避免将 nil 写入文件）
-                # 只使用临时缓存（仅在内存中，不会写入文件）
-                self.temp_tag_decision = {
-                  action: selected_action,
-                  description: selected_description,
-                  tag_action_parms: tag_action_parms,
-                  is_need_add_tag: is_need_add_tag
-                }
-              end
-            end
-          end
-        end
+      # 从tag中提取版本号，移除匹配到的前缀
+      version = if matched_prefix && !matched_prefix.empty?
+        latest_tag.sub(/^#{Regexp.escape(matched_prefix)}/, '')
+      else
+        latest_tag
       end
 
-      return [is_need_add_tag, tag_action_parms]
+      # 确保版本号格式正确（x.y.z）
+      if version =~ /^\d+\.\d+\.\d+$/
+        version
+      elsif version =~ /^\d+\.\d+$/
+        "#{version}.0"
+      elsif version =~ /^\d+$/
+        "#{version}.0.0"
+      else
+        "0.0.1"
+      end
     end
 
-    private
-
-    # 添加版本标签
-    # @param project_dir [String] 项目目录
-    # @param increment_mode [String] 版本号增加模式 (major/minor/patch)
-    # @param force_retag [Boolean] 是否强制重新打tag
-    # @param custom_tag [String] 自定义tag版本号
-    def add_release_tag(project_dir:, increment_mode: "minor", force_retag: false, custom_tag: nil)
+    # 获取Build号（从commit hash转换而来）
+    # @param project_dir [String] 项目目录路径
+    # @return [Integer] Build号（6位16进制转10进制）
+    def get_build_number_from_commit(project_dir: nil)
       raise ArgumentError, "项目目录不能为空" if project_dir.nil?
 
-      # 如果指定了自定义tag，直接使用
-      if custom_tag && !custom_tag.empty?
-        Funlog.instance.fancyinfo_start("使用指定的tag版本: #{custom_tag}")
-
-        # 确保tag有v前缀
-        new_tag = custom_tag.start_with?('v') ? custom_tag : "v#{custom_tag}"
+      # 获取git根目录
+      git_root = Pindo::GitHandler.git_root_directory(local_repo_dir: project_dir)
+      return 1 unless git_root
 
-        # 检查tag是否已存在
-        existing_tags = git!(%W(-C #{project_dir} tag -l)).split("\n")
-        if existing_tags.include?(new_tag)
-          if force_retag
-            Funlog.instance.fancyinfo_update("tag #{new_tag} 已存在，强制重新打tag")
-            git!(%W(-C #{project_dir} tag -d #{new_tag}))
-            git!(%W(-C #{project_dir} push origin :refs/tags/#{new_tag}))
-          else
-            Funlog.instance.fancyinfo_success("tag #{new_tag} 已存在")
-            Funlog.instance.fancyinfo_success("仓库路径: #{project_dir}")
-            return new_tag  # 返回已存在的 tag
-          end
-        end
+      begin
+        # 获取当前HEAD的commit hash前6位
+        commit_hash = Pindo::GitHandler.git!(%W(-C #{git_root} rev-parse HEAD)).strip[0..5]
 
-        # 创建tag并推送
-        git!(%W(-C #{project_dir} tag #{new_tag}))
-        git!(%W(-C #{project_dir} push origin #{new_tag}))
+        # 将16进制转换为10进制
+        build_number = commit_hash.to_i(16)
 
-        Funlog.instance.fancyinfo_success("创建tag: #{new_tag}")
-        Funlog.instance.fancyinfo_success("仓库路径: #{project_dir}")
-        return new_tag  # 返回新创建的 tag
-      end
+        # 确保在Android versionCode安全范围内（最大值为2^31-1）
+        max_value = 2**31 - 1
+        build_number = build_number % max_value if build_number > max_value
 
-      # 原有的自动递增逻辑
-      Funlog.instance.fancyinfo_start("开始创建初tag")
-      latest_tag = get_latest_version_tag(project_dir: project_dir)
-      if latest_tag.nil?
-        new_tag = create_next_version_tag(
-          project_dir: project_dir,
-          tag_prefix: "v",
-          increment_mode: increment_mode,
-          force_retag: false
-        )
-        Funlog.instance.fancyinfo_success("创建初始tag: #{new_tag}")
-        Funlog.instance.fancyinfo_success("仓库路径: #{project_dir}")
-        return new_tag  # 返回初始 tag
-      end
+        # 确保build_number不为0
+        build_number = 1 if build_number == 0
 
-      if is_tag_at_head?(git_root_dir: project_dir, tag_name: latest_tag)
-        Funlog.instance.fancyinfo_success("当前commit已有tag: #{latest_tag}，无需重新打tag")
-        Funlog.instance.fancyinfo_success("仓库路径: #{project_dir}")
-        return latest_tag  # 返回已存在的 tag
+        build_number
+      rescue StandardError => e
+        Funlog.instance.fancyinfo_error("获取commit hash失败: #{e.message}")
+        # 如果获取失败，返回基于时间戳的默认值
+        Time.now.to_i % 1000000 + 1
       end
+    end
 
-      Funlog.instance.fancyinfo_success("最近的上次tag是: #{latest_tag} ")
-      new_tag = create_next_version_tag(
-          project_dir: project_dir,
-          tag_prefix: "v",
-          increment_mode: increment_mode,
-          force_retag: force_retag
-      )
+  
 
-      Funlog.instance.fancyinfo_success("当前仓库的tag: #{new_tag}")
-      Funlog.instance.fancyinfo_success("仓库路径: #{project_dir}")
+    # 验证Build号是否在有效范围内
+    # @param build_number [Integer] Build号
+    # @return [Boolean] 是否有效
+    def valid_build_number?(build_number)
+      return false if build_number.nil?
 
-      new_tag  # 返回新创建的 tag
+      # Android versionCode的有效范围是1到2^31-1
+      build_number >= 1 && build_number <= 2**31 - 1
     end
 
-    # 合并到发布分支
+    # 计算构建版本号
     # @param project_dir [String] 项目目录
-    # @param release_branch [String] 发布分支名称
-    # @param coding_branch [String] 当前开发分支名称
-    def merge_to_release_branch(project_dir:, release_branch:, coding_branch:)
-      current_project_dir = project_dir
-      Funlog.instance.fancyinfo_start("开始合并到#{release_branch}分支")
-      if !coding_branch.eql?(release_branch)
-        coding_branch_commit_id = git!(%W(-C #{current_project_dir} rev-parse #{coding_branch})).strip
-        release_branch_commit_id = nil
-
-        if remote_branch_exists?(local_repo_dir: current_project_dir, branch: release_branch)
-          Funlog.instance.fancyinfo_update("存在#{release_branch}远程分支")
-          if local_branch_exists?(local_repo_dir: current_project_dir, branch: release_branch)
-            Funlog.instance.fancyinfo_update("存在#{release_branch}本地分支")
-            git!(%W(-C #{current_project_dir} checkout #{release_branch}))
-          else
-            Funlog.instance.fancyinfo_update("不存在#{release_branch}本地分支")
-            git!(%W(-C #{current_project_dir} checkout -b #{release_branch} origin/#{release_branch}))
-          end
-
-          git!(%W(-C #{current_project_dir} branch --set-upstream-to=origin/#{release_branch} #{release_branch}))
-          git!(%W(-C #{current_project_dir} fetch origin #{release_branch}))
-          git!(%W(-C #{current_project_dir} merge origin/#{release_branch}))
+    # @param tag_prefix [String] tag前缀，默认 'v'
+    # @param create_tag_type [Symbol] 创建tag类型
+    # @param version_increase_type [Symbol] 版本号增加类型
+    # @return [String] 构建版本号
+    def calculate_build_version(project_dir:, tag_prefix: 'v', create_tag_type: nil, version_increase_type: nil)
+      raise ArgumentError, "项目目录不能为空" if project_dir.nil?
 
-          # 执行合并操作，捕获输出以便后续检查冲突
-          stdout, exit_status = Executable.capture_command('git', %W(-C #{current_project_dir} merge #{coding_branch}), :capture => :out)
+      # 设置默认值
+      create_tag_type ||= Pindo::CreateTagType::NEW
+      version_increase_type ||= Pindo::VersionIncreaseType::MINI
 
-          # 检查是否有冲突（git merge 在有冲突时返回非0状态）
-          conflict_filelist = git!(%W(-C #{current_project_dir} diff --name-only --diff-filter=U --relative))
-          if !conflict_filelist.nil? && conflict_filelist.size > 0
-            puts "合并代码冲突， 冲突文件如下："
-            raise Informative, "请手动处理冲突的文件！！！"
-          else
-            git!(%W(-C #{current_project_dir} push))
-            Funlog.instance.fancyinfo_success("代码已经合并到#{release_branch}分支")
-            # 获取 release_branch 的 commit ID（处理空分支情况）
-            begin
-              release_branch_commit_id = git!(%W(-C #{current_project_dir} rev-parse #{release_branch})).strip
-            rescue => e
-              # 分支可能存在但没有提交（空分支），此时使用 coding_branch 的 commit
-              Funlog.instance.fancyinfo_update("#{release_branch}分支为空或获取commit失败，将使用当前分支commit")
-              release_branch_commit_id = coding_branch_commit_id
-            end
-          end
+      # 获取当前版本号
+      current_version = get_current_version_from_tag(
+        project_dir: project_dir,
+        tag_prefixes: [tag_prefix]
+      )
 
+      # 根据 create_tag_type 计算 build_version
+      case create_tag_type
+      when Pindo::CreateTagType::NONE, Pindo::CreateTagType::RECREATE
+        # 不创建tag或重新创建当前tag，使用当前版本号
+        current_version
+      when Pindo::CreateTagType::NEW
+        # 创建新tag，需要检查HEAD是否已有tag
+        if head_has_version_tag?(project_dir: project_dir, tag_prefix: tag_prefix)
+          # HEAD已有tag，不需要创建新tag，使用当前版本号
+          Funlog.instance.fancyinfo_success("HEAD已存在tag，使用当前版本号: #{current_version}")
+          current_version
         else
-          if local_branch_exists?(local_repo_dir: current_project_dir, branch: release_branch)
-            Funlog.instance.fancyinfo_update("不存在#{release_branch}远程分支")
-            Funlog.instance.fancyinfo_update("存在#{release_branch}本地分支")
-            git!(%W(-C #{current_project_dir} checkout #{release_branch}))
-            git!(%W(-C #{current_project_dir} checkout -b #{release_branch}_temp))
-            git!(%W(-C #{current_project_dir} checkout #{coding_branch}))
-            git!(%W(-C #{current_project_dir} branch -D #{release_branch}))
-          else
-            Funlog.instance.fancyinfo_update("不存在#{release_branch}远程分支")
-            Funlog.instance.fancyinfo_update("不存在#{release_branch}本地分支")
+          # HEAD没有tag，根据 version_increase_type 计算新版本号
+          # 解析版本号
+          parts = current_version.split('.').map(&:to_i)
+          major = parts[0] || 0
+          minor = parts[1] || 0
+          patch = parts[2] || 0
+
+          case version_increase_type
+          when Pindo::VersionIncreaseType::MAIN
+            major += 1
+            minor = 0
+            patch = 0
+          when Pindo::VersionIncreaseType::MINI
+            minor += 1
+            patch = 0
+          when Pindo::VersionIncreaseType::PATCH
+            patch += 1
           end
 
-          git!(%W(-C #{current_project_dir} checkout -b #{release_branch}))
-          git!(%W(-C #{current_project_dir} push origin #{release_branch}))
-          git!(%W(-C #{current_project_dir} branch --set-upstream-to=origin/#{release_branch} #{release_branch}))
+          new_version = "#{major}.#{minor}.#{patch}"
+          Funlog.instance.fancyinfo_success("新的版本号是: #{new_version}")
+          new_version
+        end
+      else
+        current_version
+      end
+    end
 
-          Funlog.instance.fancyinfo_success("代码已经合并到#{release_branch}分支")
-          # 获取 release_branch 的 commit ID（处理空分支情况）
-          begin
-            release_branch_commit_id = git!(%W(-C #{current_project_dir} rev-parse #{release_branch})).strip
-          rescue => e
-            # 新创建的分支，commit ID 应该与 coding_branch 相同
-            release_branch_commit_id = coding_branch_commit_id
+    # 检查HEAD是否已有版本tag
+    # @param project_dir [String] 项目目录
+    # @param tag_prefix [String] tag前缀
+    # @return [Boolean] HEAD是否有tag
+    def head_has_version_tag?(project_dir:, tag_prefix: 'v')
+      latest_tag = Pindo::GitHandler.get_latest_version_tag(
+        project_dir: project_dir,
+        tag_prefix: tag_prefix
+      )
+      return false if latest_tag.nil?
+
+      Pindo::GitHandler.is_tag_at_head?(git_root_dir: project_dir, tag_name: latest_tag)
+    end
+
+    # 创建并推送 Tag
+    # @param project_dir [String] 项目目录
+    # @param tag_name [String] tag 名称（如 v1.2.0）
+    # @param tag_type [Symbol] 创建类型 (:new, :recreate, :none)
+    # @return [String, nil] 创建的 tag 名称，或 nil（跳过时）
+    def create_and_push_tag(project_dir:, tag_name:, tag_type:)
+      raise ArgumentError, "项目目录不能为空" if project_dir.nil?
+      raise ArgumentError, "tag名称不能为空" if tag_name.nil? || tag_name.empty?
+
+      case tag_type
+      when Pindo::CreateTagType::NONE
+        Funlog.instance.fancyinfo_success("跳过创建 Tag")
+        return nil
+      when Pindo::CreateTagType::RECREATE
+        # 删除旧 tag（本地和远程）
+        if Pindo::GitHandler.remote_tag_exists?(local_repo_dir: project_dir, tag_name: tag_name)
+          Funlog.instance.fancyinfo_update("删除远程 Tag: #{tag_name}")
+          Pindo::GitHandler.git!(%W(-C #{project_dir} push origin :refs/tags/#{tag_name}))
+        end
+        if Pindo::GitHandler.local_tag_exists?(local_repo_dir: project_dir, tag_name: tag_name)
+          Funlog.instance.fancyinfo_update("删除本地 Tag: #{tag_name}")
+          Pindo::GitHandler.git!(%W(-C #{project_dir} tag -d #{tag_name}))
+        end
+      when Pindo::CreateTagType::NEW
+        local_exists = Pindo::GitHandler.local_tag_exists?(local_repo_dir: project_dir, tag_name: tag_name)
+        remote_exists = Pindo::GitHandler.remote_tag_exists?(local_repo_dir: project_dir, tag_name: tag_name)
+
+        # 如果 tag 在 HEAD 上，不需要重新创建
+        if local_exists && Pindo::GitHandler.is_tag_at_head?(git_root_dir: project_dir, tag_name: tag_name)
+          if !remote_exists
+            # 本地存在且在 HEAD，但远程不存在，推送到远程
+            Pindo::GitHandler.git!(%W(-C #{project_dir} push origin #{tag_name}))
+            Funlog.instance.fancyinfo_success("推送 Tag 到远程: #{tag_name}")
+          else
+            Funlog.instance.fancyinfo_success("Tag 已存在且在 HEAD: #{tag_name}")
           end
+          return tag_name
         end
 
-        git!(%W(-C #{current_project_dir} checkout #{coding_branch}))
-        if release_branch_commit_id && !release_branch_commit_id.eql?(coding_branch_commit_id)
-          git!(%W(-C #{current_project_dir} merge #{release_branch}))
-          Funlog.instance.fancyinfo_success("已将#{release_branch}合并到#{coding_branch}")
+        # tag 不在 HEAD 上，需要删除后重新创建
+        if remote_exists
+          Funlog.instance.fancyinfo_update("删除远程 Tag: #{tag_name}")
+          Pindo::GitHandler.git!(%W(-C #{project_dir} push origin :refs/tags/#{tag_name}))
         end
-        git!(%W(-C #{current_project_dir} push origin #{coding_branch}))
-        Funlog.instance.fancyinfo_success("已推送#{coding_branch}分支到远程")
-      else
-        Funlog.instance.fancyinfo_success("代码处于#{coding_branch}分支,无需合并")
+        if local_exists
+          Funlog.instance.fancyinfo_update("删除本地 Tag: #{tag_name}")
+          Pindo::GitHandler.git!(%W(-C #{project_dir} tag -d #{tag_name}))
+        end
+        # 继续创建新 tag
       end
+
+      # 创建并推送 tag
+      Pindo::GitHandler.git!(%W(-C #{project_dir} tag #{tag_name}))
+      Pindo::GitHandler.git!(%W(-C #{project_dir} push origin #{tag_name}))
+      Funlog.instance.fancyinfo_success("创建并推送 Tag: #{tag_name}")
+      tag_name
     end
+
   end
 end