pindo 5.14.7 → 5.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e61c4fa7bc1f944011a7d2da6ea5f88e6964cf4156fbfc820a82f87f8376b15
-  data.tar.gz: '0826f4b21c1fdd8145763b8357dddfa7f6c06a461b128bb458b7c75886ba5208'
+  metadata.gz: f82f06b4cb4ed845ca62c0db43e4684b141d87b8271b705a2a4de0e0a9c8355b
+  data.tar.gz: 7b77b67d53e8f1ca601f32190d8d6534d146837a302facce49c7afa782ecd47f
 SHA512:
-  metadata.gz: a1379dd0f212e82aad3c889d9c06374810441728700616d9a2293c647bbe0272318d744dcfd4056edf69d8bde847a9394225c334a3909e419f34321d38d9f29f
-  data.tar.gz: df9c68524dbdbd81f29e3134c9b1a25de3e6fc57e29346b5beae93bcccb8ac1186bbfe7e3f4a86dbfb81ebc5356f91eeb852cf9a6f504144225c3715e9a63975
+  metadata.gz: f051bfa4fb0aa773eaf7d7a20d489e17d065bdede2c78652dd172ec2a3da5f95ae19700d05e6748f3442487fd96e18a7b3040043a4f906e257415353b73a392a
+  data.tar.gz: f056935b0928d4e48dd0e6bb88f321d64a2b118eee92ef3ce767697c039868ebc987394e36deacbbcb6ba1111cc8486b93bbc99c71a6f4c71a297bc9a4f3f575

data/lib/pindo/base/aeshelper.rb

@@ -21,26 +21,7 @@ module Pindo
       unless password
           puts "\e[33m[DEBUG] Keychain中未找到密码，需要用户输入: #{server_name}\e[0m" if ENV['PINDO_DEBUG']
           password = FastlaneCore::Helper.ask_password(message: "请输入证书仓库的加密密码: ", confirm: true)
-
-          # 尝试添加密码到Keychain
-          begin
-            # 先尝试删除旧密码（如果存在）
-            begin
-              Security::InternetPassword.delete(server: server_name)
-              puts "\e[33m[DEBUG] 删除Keychain中的旧密码项: #{server_name}\e[0m" if ENV['PINDO_DEBUG']
-            rescue => delete_error
-              # 如果不存在就忽略删除错误
-              puts "\e[33m[DEBUG] 旧密码项不存在或删除失败: #{delete_error.message}\e[0m" if ENV['PINDO_DEBUG']
-            end
-
-            # 添加新密码到Keychain
-            Security::InternetPassword.add(server_name, "", password)
-            puts "\e[32m✓ 密码已保存到Keychain: #{server_name}\e[0m"
-          rescue => e
-            # 如果保存失败，警告用户但不影响继续使用
-            puts "\e[31m⚠ 密码保存到Keychain失败: #{e.message}\e[0m"
-            puts "\e[31m⚠ 下次使用时需要重新输入密码\e[0m"
-          end
+          puts "\e[33m[DEBUG] 用户输入密码成功，等待验证后保存到Keychain\e[0m" if ENV['PINDO_DEBUG']
       else
           puts "\e[32m[DEBUG] 从Keychain获取密码成功: #{server_name}\e[0m" if ENV['PINDO_DEBUG']
       end
@@ -50,12 +31,62 @@ module Pindo
 
     def self.delete_password(keychain_name:nil)
       server_name = ["match", keychain_name].join("_")
-      Security::InternetPassword.delete(server:server_name)
+      # 静默删除密码，不输出 keychain 详细信息（文件描述符级别重定向）
+      begin
+        old_stdout = STDOUT.dup
+        old_stderr = STDERR.dup
+        STDOUT.reopen(File::NULL, 'w')
+        STDERR.reopen(File::NULL, 'w')
+
+        Security::InternetPassword.delete(server:server_name)
+      ensure
+        STDOUT.reopen(old_stdout)
+        STDERR.reopen(old_stderr)
+        old_stdout.close
+        old_stderr.close
+      end
+    rescue => e
+      # 忽略错误（密码可能不存在）
     end
 
     def self.store_password(keychain_name:nil, password:nil)
       server_name = ["match", keychain_name].join("_")
-      Security::InternetPassword.add(server_name, "", password)
+
+      # 先检查密码是否已存在，如果存在则无需重复保存
+      begin
+        item = Security::InternetPassword.find(server: server_name)
+        if item && item.password == password
+          puts "\e[33m[DEBUG] 密码已存在于Keychain，跳过保存: #{server_name}\e[0m" if ENV['PINDO_DEBUG']
+          return
+        end
+      rescue => e
+        # 密码不存在，继续保存流程
+      end
+
+      # 静默操作，避免输出错误信息（文件描述符级别重定向）
+      begin
+        old_stdout = STDOUT.dup
+        old_stderr = STDERR.dup
+        STDOUT.reopen(File::NULL, 'w')
+        STDERR.reopen(File::NULL, 'w')
+
+        # 先尝试删除旧密码（如果存在但不同）
+        begin
+          Security::InternetPassword.delete(server:server_name)
+        rescue => e
+          # 忽略删除错误（密码可能不存在）
+        end
+
+        # 添加新密码
+        Security::InternetPassword.add(server_name, "", password)
+      ensure
+        STDOUT.reopen(old_stdout)
+        STDERR.reopen(old_stderr)
+        old_stdout.close
+        old_stderr.close
+      end
+    rescue => e
+      # 忽略错误，不影响主流程
     end
 
 

data/lib/pindo/base/git_handler.rb

@@ -4,6 +4,7 @@ require 'pindo/base/informative'
 require 'etc'
 require 'claide'
 require 'highline/import'
+require 'pindo/options/helpers/git_constants'
 
 module Pindo
   # Git 操作处理类
@@ -517,17 +518,20 @@ module Pindo
 
                 # 根据 process_type 执行对应操作
                 case process_type
-                when 'commit', '全部提交'
+                when Pindo::UncommittedFilesProcessType::NONE
+                    # 没有未提交的文件，无需处理
+                    return
+                when Pindo::UncommittedFilesProcessType::COMMIT
                     handle_commit_all(current_project_dir, coding_branch, commit_message)
-                when 'reset', '全部丢弃更改，回滚代码', 'delete', '全部删除'
+                when Pindo::UncommittedFilesProcessType::RESET
                     handle_delete_all(current_project_dir, coding_branch)
-                when 'stash', '保存到stash区域', '保存到stash区域（改代码本次不生效）'
+                when Pindo::UncommittedFilesProcessType::STASH
                     handle_stash(current_project_dir, coding_branch)
-                when 'skip', '跳过'
+                when Pindo::UncommittedFilesProcessType::SKIP
                     # 跳过处理，不做任何操作
                     Funlog.instance.warning("跳过提交，可能导致 build number 与代码仓库不一致")
                     return
-                when 'exit', '先退出，手动来处理退出'
+                when Pindo::UncommittedFilesProcessType::EXIT
                     raise Informative, "请手动处理未提交的文件！！！"
                 else
                     raise ArgumentError, "不支持的处理方式: #{process_type}"
@@ -620,13 +624,16 @@ module Pindo
 
             # 生成 stash 信息，包含分支名和时间戳
             timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
-            stash_message = "pindo on #{branch} - #{timestamp}"
+            # 统一使用 pindo_stash 前缀，方便查找和还原
+            stash_name = "pindo_stash_#{Time.now.strftime('%Y%m%d%H%M%S')}_#{rand(1000)}"
+            stash_message = "#{stash_name} (on #{branch} at #{timestamp})"
 
             # 保存到 stash（包含未追踪的文件）
             git!(%W(-C #{project_dir} stash push -u -m #{stash_message}))
 
             Funlog.instance.fancyinfo_success("文件已保存到 stash 区域!")
-            Funlog.instance.fancyinfo_success("stash 信息: #{stash_message}")
+            Funlog.instance.fancyinfo_success("stash key: #{stash_name}")
+            Funlog.instance.fancyinfo_success("stash msg: #{stash_message}")
 
             # 显示当前 stash 列表
             stash_list = git!(%W(-C #{project_dir} stash list))
@@ -662,8 +669,12 @@ module Pindo
 
       # 获取最新的符合规范的 commit
       # @param project_dir [String] 项目目录路径
+      # @param tag_prefix [String] tag前缀，用于检查 HEAD 是否有版本 tag，默认 'v'
       # @return [Hash] 包含 :commit_id, :commit_time, :commit_desc
-      def get_latest_conventional_commit(project_dir:nil)
+      # 优先级：
+      #   1. 如果 HEAD 存在版本 tag，直接返回 HEAD（认为有 tag 的 commit 是有效的发布节点）
+      #   2. 否则，返回最新的符合 Conventional Commits 规范的提交
+      def get_latest_conventional_commit(project_dir:nil, tag_prefix: 'v')
           result = {
             commit_id: nil,
             commit_time: nil,
@@ -672,9 +683,27 @@ module Pindo
 
           return result if project_dir.nil? || !File.exist?(project_dir)
 
-          Dir.chdir(project_dir) do
-            # 获取最近 15 条 commit 历史
-            output = `git log -15 --format="%H|%ci|%s" 2>/dev/null`.strip
+          # 获取 git 根目录
+          git_root = git_root_directory(local_repo_dir: project_dir)
+          return result unless git_root
+
+          begin
+            # 优先级 1: 检查 HEAD 是否有版本 tag
+            if head_has_version_tag?(project_dir: git_root, tag_prefix: tag_prefix)
+              # HEAD 有版本 tag，直接返回 HEAD 的 commit 信息
+              head_info = git!(%W(-C #{git_root} log -1 --format=%H|%ci|%s HEAD)).strip
+              if !head_info.empty?
+                parts = head_info.split('|', 3)
+                result[:commit_id] = parts[0]
+                result[:commit_time] = parts[1]
+                result[:commit_desc] = parts[2]&.force_encoding('UTF-8')&.scrub('')
+                puts "  HEAD 存在版本 tag，使用 HEAD commit: #{result[:commit_desc]}"
+                return result
+              end
+            end
+
+            # 优先级 2: 获取最近 15 条 commit 历史（排除 merge commits）
+            output = git!(%W(-C #{git_root} log -15 --no-merges --format=%H|%ci|%s)).strip
 
             if output.empty?
               Funlog.instance.warning("未找到 git commit 历史")
@@ -687,17 +716,20 @@ module Pindo
               {
                 commit_id: parts[0],
                 commit_time: parts[1],
-                commit_desc: parts[2]
+                commit_desc: parts[2]&.force_encoding('UTF-8')&.scrub('')
               }
             end
 
-            # 定义符合规范的提交类型
-            valid_prefixes = ['feat:', 'fix:', 'docs:', 'style:', 'refactor:', 'perf:', 'test:', 'build:', 'ci:', 'chore:', 'revert:']
+            # 定义符合规范的提交类型（Conventional Commits 规范）
+            valid_types = ['feat', 'fix', 'docs', 'style', 'refactor', 'perf', 'test', 'build', 'ci', 'chore', 'revert']
 
-            # 筛选符合规范的提交
+            # 筛选符合规范的提交（支持 type: 和 type(scope): 两种格式）
             conventional_commits = commits.select do |commit|
-              desc = commit[:commit_desc].to_s.strip
-              valid_prefixes.any? { |prefix| desc.downcase.start_with?(prefix) }
+              desc = commit[:commit_desc].to_s.strip.downcase
+              # 匹配 "type:" 或 "type(" 格式（允许 scope）
+              valid_types.any? do |type|
+                desc.start_with?("#{type}:") || desc.start_with?("#{type}(")
+              end
             end
 
             if conventional_commits.empty?
@@ -717,6 +749,9 @@ module Pindo
 
               puts "  找到符合规范的提交: #{result[:commit_desc]}"
             end
+          rescue StandardError => e
+            Funlog.instance.warning("获取 conventional commit 失败: #{e.message}")
+            return result
           end
 
           result
@@ -780,6 +815,20 @@ module Pindo
           new_tag
       end
 
+      # 检查 HEAD 是否已有版本 tag
+      # @param project_dir [String] 项目目录
+      # @param tag_prefix [String] tag前缀，默认 'v'
+      # @return [Boolean] HEAD 是否有版本 tag
+      def head_has_version_tag?(project_dir:, tag_prefix: 'v')
+        latest_tag = get_latest_version_tag(
+          project_dir: project_dir,
+          tag_prefix: tag_prefix
+        )
+        return false if latest_tag.nil?
+
+        is_tag_at_head?(git_root_dir: project_dir, tag_name: latest_tag)
+      end
+
       # 检查仓库是否有未提交的更改（包括未暂存和已暂存的更改）
       # @param git_root_dir [String] 项目目录路径
       # @return [Boolean] 如果有未提交的更改返回true，否则返回false
@@ -804,8 +853,8 @@ module Pindo
           return false if git_root_dir.nil? || tag_name.nil?
 
           begin
-              # 获取tag的commit hash
-              tag_commit = git!(%W(-C #{git_root_dir} rev-parse #{tag_name})).strip
+              # 获取tag指向的commit hash（使用^{commit}解引用，支持annotated tag和lightweight tag）
+              tag_commit = git!(%W(-C #{git_root_dir} rev-parse #{tag_name}^{commit})).strip
               # 获取HEAD的commit hash
               head_commit = git!(%W(-C #{git_root_dir} rev-parse HEAD)).strip
 
@@ -819,26 +868,26 @@ module Pindo
       # 获取未提交文件的处理方式
       # @param project_dir [String] 项目目录路径
       # @param interactive [Boolean] 是否允许交互，默认为 true
-      # @param default_process_type [String] 当没有未提交文件时的默认处理方式，默认为 'skip'
-      # @return [String] 处理方式 ('commit', 'skip', 'reset', 'stash', 'exit')
-      def get_uncommitted_files_process_type(project_dir:, interactive: true, default_process_type: 'skip')
+      # @param default_process_type [Symbol, nil] 非交互模式下的默认处理方式，默认为 nil
+      # @return [Symbol] UncommittedFilesProcessType 枚举常量
+      def get_uncommitted_files_process_type(project_dir:, interactive: true, default_process_type: nil)
         # 1. 检查是否有未提交的文件
         uncommitted_files = get_uncommitted_files(project_dir: project_dir)
 
-        # 2. 如果没有未提交的文件，返回默认处理方式
+        # 2. 如果没有未提交的文件，返回 NONE 类型
         return default_process_type if uncommitted_files.nil? || uncommitted_files.empty?
 
-        # 3. 如果非交互模式，默认跳过
+        # 3. 如果非交互模式，使用指定的处理方式
         unless interactive
-          Funlog.instance.info("当前处于非交互模式，默认跳过未提交文件的处理。")
-          return 'skip'
+          Funlog.instance.info("当前处于非交互模式，使用指定的处理方式: #{default_process_type}")
+          return default_process_type
         end
 
         # 4. 获取 Git 根目录并获取当前分支名
         git_root = git_root_directory(local_repo_dir: project_dir)
         unless git_root
           Funlog.instance.fancyinfo_warning("当前目录不是Git仓库")
-          return 'skip'
+          return Pindo::UncommittedFilesProcessType::SKIP
         end
 
         current_branch = git!(%W(-C #{git_root} rev-parse --abbrev-ref HEAD)).strip
@@ -849,11 +898,11 @@ module Pindo
         cli.choose do |menu|
           menu.header = "仓库有未提交的修改，请选择处理方式"
           menu.prompt = "请输入选项(1/2/3/4/5):"
-          menu.choice("(commit) 全部提交") { 'commit' }
-          menu.choice("(skip) 跳过并且不作任何修改，继续执行") { 'skip' }
-          menu.choice("(reset) 全部丢弃更改，回滚代码") { 'reset' }
-          menu.choice("(stash) 保存到stash区域（该部分代码本次不生效）") { 'stash' }
-          menu.choice("(exit) 先退出，手动来处理退出") { 'exit' }
+          menu.choice("(commit) 全部提交") { Pindo::UncommittedFilesProcessType::COMMIT }
+          menu.choice("(skip) 跳过并且不作任何修改，继续执行") { Pindo::UncommittedFilesProcessType::SKIP }
+          menu.choice("(reset) 全部丢弃更改，回滚代码") { Pindo::UncommittedFilesProcessType::RESET }
+          menu.choice("(stash) 保存到stash区域（该部分代码本次不生效）") { Pindo::UncommittedFilesProcessType::STASH }
+          menu.choice("(exit) 先退出，手动来处理退出") { Pindo::UncommittedFilesProcessType::EXIT }
         end
       end
 
@@ -1067,6 +1116,220 @@ module Pindo
         end
       end
 
+      # 初始化并递归更新所有 Git 子模块
+      # @param local_repo_dir [String] Git 仓库目录路径
+      # @param force [Boolean] 是否强制重新初始化子模块
+      # @return [Boolean] 成功返回 true，无子模块返回 false
+      def update_submodules(local_repo_dir:, force: false)
+        raise ArgumentError, "项目目录不能为空" if local_repo_dir.nil?
+
+        # 验证是否是 Git 仓库
+        unless is_git_directory?(local_repo_dir: local_repo_dir)
+          raise Informative, "#{local_repo_dir} 不是有效的 Git 仓库！"
+        end
+
+        # 检查 .gitmodules 文件是否存在
+        git_root = git_root_directory(local_repo_dir: local_repo_dir)
+        gitmodules_path = File.join(git_root, '.gitmodules')
+
+        unless File.exist?(gitmodules_path)
+          Funlog.instance.fancyinfo_warning("当前仓库没有子模块配置文件 (.gitmodules)")
+          return false
+        end
+
+        # 显示子模块信息
+        Funlog.instance.fancyinfo_start("正在读取子模块配置...")
+        submodules_count = parse_gitmodules_count(gitmodules_path)
+        Funlog.instance.fancyinfo_success("检测到 #{submodules_count} 个子模块")
+
+        # 检查子模块路径冲突
+        conflicts = check_submodule_path_conflicts(git_root, gitmodules_path)
+        unless conflicts.empty?
+          if force
+            # 使用 --force 参数，自动清理冲突路径
+            Funlog.instance.fancyinfo_start("检测到 #{conflicts.size} 个路径冲突，正在清理...")
+            conflicts.each do |conflict|
+              begin
+                FileUtils.rm_rf(conflict[:full_path])
+                Funlog.instance.fancyinfo_success("已清理: #{conflict[:path]} (包含 #{conflict[:files]} 个文件)")
+              rescue => e
+                Funlog.instance.fancyinfo_error("清理失败: #{conflict[:path]} - #{e.message}")
+                raise Informative, "无法清理路径冲突：#{conflict[:path]}\n#{e.message}"
+              end
+            end
+          else
+            # 不使用 --force，报错退出
+            Funlog.instance.fancyinfo_error("检测到 #{conflicts.size} 个子模块路径冲突")
+            puts "\n以下路径已存在但不是 Git 仓库，其中的文件会污染子模块：\n".yellow
+            conflicts.each do |conflict|
+              puts "  • #{conflict[:path]} (包含 #{conflict[:files]} 个文件)".yellow
+            end
+            puts "\n请选择处理方式：".yellow
+            puts "  1. 使用 --force 参数自动清理这些目录".yellow
+            puts "  2. 手动删除或备份这些目录后重新执行\n".yellow
+            raise Informative, "子模块路径冲突！请处理后重试。"
+          end
+        end
+
+        # 构建 git submodule update 命令
+        args = %W(-C #{git_root} submodule update --init --recursive)
+        args << '--force' if force
+        args << '--progress'
+
+        # 执行子模块更新
+        begin
+          Funlog.instance.fancyinfo_start("正在初始化和更新所有子模块...")
+          output = git!(args)
+          Funlog.instance.fancyinfo_success("子模块更新完成!")
+
+          # 显示子模块状态
+          display_submodules_status(git_root)
+
+          # 检查子模块是否有未提交的内容
+          check_submodule_dirty_state(git_root, gitmodules_path)
+
+          true
+        rescue StandardError => e
+          Funlog.instance.fancyinfo_error("子模块更新失败: #{e.message}")
+          raise Informative, "子模块更新失败！\n详细错误：#{e.message}"
+        end
+      end
+
+      # 解析 .gitmodules 文件，统计子模块数量
+      # @param gitmodules_path [String] .gitmodules 文件路径
+      # @return [Integer] 子模块数量
+      def parse_gitmodules_count(gitmodules_path)
+        return 0 unless File.exist?(gitmodules_path)
+
+        content = File.read(gitmodules_path)
+        # 统计 [submodule "xxx"] 的数量
+        content.scan(/\[submodule\s+"[^"]+"\]/).count
+      end
+
+      # 显示子模块状态信息
+      # @param git_root [String] Git 根目录
+      def display_submodules_status(git_root)
+        begin
+          status_output = git!(%W(-C #{git_root} submodule status --recursive))
+
+          unless status_output.nil? || status_output.strip.empty?
+            puts "\n" + "═" * 60
+            puts "子模块状态".center(60)
+            puts "═" * 60
+            puts status_output
+            puts "═" * 60 + "\n"
+          end
+        rescue StandardError => e
+          Funlog.instance.warning("无法获取子模块状态: #{e.message}")
+        end
+      end
+
+      # 解析 .gitmodules 文件，提取所有子模块路径
+      # @param gitmodules_path [String] .gitmodules 文件路径
+      # @return [Array<String>] 子模块路径列表
+      def parse_submodule_paths(gitmodules_path)
+        return [] unless File.exist?(gitmodules_path)
+
+        content = File.read(gitmodules_path)
+        paths = []
+
+        # 匹配 path = xxx 行
+        content.scan(/^\s*path\s*=\s*(.+)$/) do |match|
+          paths << match[0].strip
+        end
+
+        paths
+      end
+
+      # 检查子模块路径冲突
+      # @param git_root [String] Git 根目录
+      # @param gitmodules_path [String] .gitmodules 文件路径
+      # @return [Array<Hash>] 冲突列表，每个元素包含 :path, :full_path, :files
+      def check_submodule_path_conflicts(git_root, gitmodules_path)
+        submodule_paths = parse_submodule_paths(gitmodules_path)
+        conflicts = []
+
+        submodule_paths.each do |path|
+          full_path = File.join(git_root, path)
+
+          # 检查：路径存在 && 不是 git 仓库 && 不为空
+          if File.exist?(full_path) && File.directory?(full_path)
+            git_dir = File.join(full_path, '.git')
+
+            unless File.exist?(git_dir)
+              # 检查目录是否为空
+              unless Dir.empty?(full_path)
+                conflicts << {
+                  path: path,
+                  full_path: full_path,
+                  files: Dir.children(full_path).size
+                }
+              end
+            end
+          end
+        end
+
+        conflicts
+      end
+
+      # 检查子模块是否有未提交的内容（脏数据）
+      # @param git_root [String] Git 根目录
+      # @param gitmodules_path [String] .gitmodules 文件路径
+      def check_submodule_dirty_state(git_root, gitmodules_path)
+        submodule_paths = parse_submodule_paths(gitmodules_path)
+        dirty_submodules = []
+
+        submodule_paths.each do |path|
+          full_path = File.join(git_root, path)
+          next unless File.exist?(full_path)
+
+          begin
+            # 使用 git status --porcelain 检查是否有修改
+            status = git!(%W(-C #{full_path} status --porcelain))
+
+            unless status.nil? || status.strip.empty?
+              # 统计修改类型
+              lines = status.strip.split("\n")
+              untracked = lines.count { |line| line.start_with?('??') }
+              modified = lines.count { |line| line.start_with?(' M', 'M ', 'MM') }
+              added = lines.count { |line| line.start_with?('A ') }
+              deleted = lines.count { |line| line.start_with?(' D', 'D ') }
+
+              dirty_submodules << {
+                path: path,
+                untracked: untracked,
+                modified: modified,
+                added: added,
+                deleted: deleted,
+                total: lines.size
+              }
+            end
+          rescue => e
+            # 忽略错误，继续检查其他子模块
+          end
+        end
+
+        # 如果有脏数据，显示警告
+        unless dirty_submodules.empty?
+          puts "\n"
+          Funlog.instance.fancyinfo_warning("⚠️  检测到 #{dirty_submodules.size} 个子模块包含未提交的内容")
+          puts "\n以下子模块有未提交的修改：\n".yellow
+
+          dirty_submodules.each do |submodule|
+            puts "  • #{submodule[:path]}:".yellow
+            puts "    - 未跟踪文件: #{submodule[:untracked]} 个".yellow if submodule[:untracked] > 0
+            puts "    - 已修改文件: #{submodule[:modified]} 个".yellow if submodule[:modified] > 0
+            puts "    - 已添加文件: #{submodule[:added]} 个".yellow if submodule[:added] > 0
+            puts "    - 已删除文件: #{submodule[:deleted]} 个".yellow if submodule[:deleted] > 0
+          end
+
+          puts "\n建议处理方式：".yellow
+          puts "  1. 进入子模块目录处理这些修改：cd #{dirty_submodules.first[:path]}".yellow
+          puts "  2. 在子模块中提交修改：git add . && git commit -m 'message'".yellow
+          puts "  3. 或者丢弃修改：git clean -fd && git reset --hard\n".yellow
+        end
+      end
+
     end
   end
 end

data/lib/pindo/client/giteeclient.rb

@@ -41,21 +41,30 @@ module Pindo
             
             # puts body_str
 
-            con = Faraday.new 
+            con = Faraday.new
             res = con.post do |req|
                 req.url url
                 req.headers['Content-Type'] = 'application/json'
                 req.body =  body_str
             end
 
-            # puts res.body
+            # 解析 JSON 响应
+            begin
+              response_body = JSON.parse(res.body)
+            rescue JSON::ParserError => e
+              puts "[❌] Gitee API 响应解析失败: #{e.message}"
+              puts "响应内容: #{res.body}"
+              return false
+            end
 
-            # puts res.body
-            if  res.body['error'].nil?
-              puts "Create success !!!"
+            # 检查响应状态
+            if response_body['error'].nil? && response_body['message'].nil?
+              puts "[✔] Gitee 仓库创建成功: #{repo_name}"
               return true
             else
-              puts res.body['error']
+              error_msg = response_body['error'] || response_body['message'] || '未知错误'
+              puts "[❌] Gitee 仓库创建失败: #{error_msg}"
+              puts "响应详情: #{response_body}" if ENV['PINDO_DEBUG']
               return false
             end
         end

data/lib/pindo/command/android/autobuild.rb

@@ -130,9 +130,10 @@ module Pindo
 
           # Git 参数
           @args_release_branch = @options[:release_branch] || 'master'
-          @args_ver_inc = Pindo::Options::GitOptions.parse_version_increase_type(@options[:ver_inc] || 'mini')
-          @args_tag_type = Pindo::Options::GitOptions.parse_create_tag_type(@options[:tag_type] || 'new')
+          @args_ver_inc = Pindo::Options::GitOptions.parse_version_increase_type(@options[:ver_inc])
+          @args_tag_type = Pindo::Options::GitOptions.parse_create_tag_type(@options[:tag_type])
           @args_tag_pre = @options[:tag_pre] || 'v'
+          @args_git_commit = Pindo::Options::GitOptions.parse_git_commit_type(@options[:git_commit])
 
           super
           @additional_args = argv.remainder!
@@ -212,7 +213,8 @@ module Pindo
             # 提前询问用户如何处理未提交的文件
             process_type = Pindo::GitHandler.get_uncommitted_files_process_type(
                 project_dir: config[:project_path],
-                interactive: true
+                interactive: @args_git_commit.nil?,
+                default_process_type: @args_git_commit
             )
             git_commit_task = Pindo::TaskSystem::GitCommitTask.new(
               config[:project_path],
@@ -341,7 +343,7 @@ module Pindo
               git_app_info_obj, git_workflow_info = PgyerHelper.share_instace.prepare_upload(
                 working_directory: config[:project_path],
                 proj_name: @args_proj_name,
-                package_type: "",  # package_type 在 manage_type=git 时会被忽略
+                package_type: nil,  # package_type 在 manage_type=git 时会被忽略
                 manage_type: "git"
               )
 
@@ -379,7 +381,7 @@ module Pindo
               git_app_info_obj, git_workflow_info = PgyerHelper.share_instace.prepare_upload(
                 working_directory: config[:project_path],
                 proj_name: @args_proj_name,
-                package_type: "",
+                package_type: nil,
                 manage_type: "git"
               )
 

data/lib/pindo/command/appstore/autobuild.rb

@@ -6,6 +6,7 @@ require 'fileutils'
 require 'pindo/base/executable'
 require 'pindo/base/git_handler'
 require 'pindo/module/build/build_helper'
+require 'pindo/options/helpers/git_constants'
 require 'pindo/module/xcode/xcode_app_config'
 require 'pindo/module/xcode/xcode_build_helper'
 require 'pindo/config/ios_config_parser'
@@ -94,8 +95,9 @@ module Pindo
 
           # Git 参数
           @args_release_branch = @options[:release_branch] || 'master'
-          @args_tag_type = Pindo::Options::GitOptions.parse_create_tag_type(@options[:tag_type] || 'new')
+          @args_tag_type = Pindo::Options::GitOptions.parse_create_tag_type(@options[:tag_type])
           @args_tag_pre = @options[:tag_pre] || 'ios_release_'
+          @args_git_commit = Pindo::Options::GitOptions.parse_git_commit_type(@options[:git_commit]) || Pindo::UncommittedFilesProcessType::SKIP
 
           super(argv)
         end
@@ -191,7 +193,8 @@ module Pindo
             # 提前询问用户如何处理未提交的文件
             process_type = Pindo::GitHandler.get_uncommitted_files_process_type(
                 project_dir: project_path,
-                interactive: true
+                interactive: false,
+                default_process_type: @args_git_commit
             )
             
             git_commit_task = Pindo::TaskSystem::GitCommitTask.new(

data/lib/pindo/command/appstore/cert.rb

@@ -166,7 +166,13 @@ module Pindo
               renew_flag: @renew_cert_flag
             )
             config = FastlaneCore::Configuration.create(Match::Options.available_options, values)
+
+            # 注意：fastlane match 可能会产生 '--template_name' 弃用警告
+            # 这是 fastlane 内部使用的参数，在 App Store Connect API v3.8.0 中已弃用
+            # 该警告不影响功能，fastlane 会自动处理兼容性
+            # 参考：https://docs.fastlane.tools/actions/match/#managed-capabilities
             Match::Runner.new.run(config)
+
             provisioning_info_array = Pindo::XcodeCertHelper.create_provisioning_info_array(
               build_type: @cert_type,
               platform_type: @platform_type