pindo 5.3.7 → 5.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3dda2ad2ab5ff48d50a3ff942ac1407f1a641fe132698af831e86153695ab822
-  data.tar.gz: '08347a7f63339395c8572cfed87bc6ab3aac40289dece2ff52ba5486a180c879'
+  metadata.gz: 56fcfdba92a710c2c7ab85226d30f305cbb1fca5d3fccb57d5c62e6593c8afbb
+  data.tar.gz: a2d7a5c80ca642869ce4f79ef9dca35383b7426c5cf15077937137db899b4eab
 SHA512:
-  metadata.gz: a9535a1eb328a8f8b38eebaccff014192b485d818c9fbe5a1b1053e720b8505f1b3a2568105fa4d4ee8206690e11bf6867222e3f74bbb89a45dde7d5d30ab7ba
-  data.tar.gz: ddc013f1c82a0b7e6705612eaf9e5c23006fab8ccb12c937facf9e6769b1de6d77529df0b0ff52fc4cd6b1beb3ebd0011591fc81af81b61757cc18c891719a2f
+  metadata.gz: 54cef915058ddb2d765e136181c13b1e1e6e1376316e8b443a19e54bf03da4afb7763564348c7fe04099cb87476e3547664016dd479936423243360036a9fbe4
+  data.tar.gz: 86a5729f1929db20b938254ae541c1310fce8dba85d7d0088966f197aad668723c11270775bbdcd8651ca86609d357e69fac7dfd8e6d1459133d58fe9357bccd

data/lib/pindo/base/pindocontext.rb

@@ -10,75 +10,113 @@ module Pindo
     attr_reader :current_command, :current_directory
 
     def initialize
-      @current_command = nil
-      @current_directory = nil
-      @is_nested_call = false
-      @memory_selections = {}  # 内存缓存
-      @file_cache_loaded = false  # 标记文件缓存是否已加载
+      @current_command = nil      # 根命令（第一个设置的命令）
+      @current_directory = nil    # 项目路径
+      @memory_selections = {}      # 三级结构的内存缓存
+      @file_cache_loaded = false   # 标记文件缓存是否已加载
+      @cache_enabled = false       # 默认禁用缓存
+      @command_group = nil         # 命令组名称
       ensure_cache_dir
     end
 
     # 设置当前上下文
-    def set_context(command, directory = nil)
-      # 判断是否是嵌套调用
-      if @current_command.nil?
-        # 第一次设置，是顶层命令
-        @is_nested_call = false
-        @current_command = normalize_command(command)
-        @current_directory = directory || Dir.pwd
-
-        # 顶层命令时加载文件缓存并确认
-        if !@file_cache_loaded
-          load_file_cache_with_confirmation
-          @file_cache_loaded = true
-        end
+    def set_context(command, directory = nil, options = {})
+      # 如果已有命令在执行，这是嵌套调用，不需要做任何事
+      unless @current_command.nil?
+        puts "[PindoContext] 嵌套调用 #{command}，使用已有上下文 (根命令: #{@current_command}，命令组: #{@command_group})"
+        return
+      end
 
-        puts "[PindoContext] 顶层命令: #{command}" if ENV['PINDO_DEBUG']
+      # 第一次设置，是顶层命令
+      @current_command = command  # 保持原始命令名称
+      @current_directory = directory || Dir.pwd  # 固定项目目录
+
+      # 从选项中获取缓存配置
+      @cache_enabled = options[:cache_enabled] || false
+      # 使用 get_command_group 来确定缓存组
+      @command_group = get_command_group(command)
+
+      puts "\n[PindoContext] ========== 设置顶层命令上下文 =========="
+      puts "[PindoContext] 命令: #{command}"
+      puts "[PindoContext] 目录: #{@current_directory}"
+      puts "[PindoContext] 缓存启用: #{@cache_enabled}"
+      puts "[PindoContext] 命令组: #{@command_group}"
+      puts "[PindoContext] options: #{options.inspect}"
+
+      # 仅在启用缓存时加载文件缓存
+      if @cache_enabled && !@file_cache_loaded
+        puts "[PindoContext] 准备加载文件缓存..."
+        load_file_cache_with_confirmation
+        @file_cache_loaded = true
       else
-        # 已有命令在执行，是嵌套调用
-        @is_nested_call = true
-        # 保持原有的命令组不变，确保缓存共享
-        puts "[PindoContext] 嵌套调用: #{command} (使用 #{@current_command} 的缓存)" if ENV['PINDO_DEBUG']
+        if !@cache_enabled
+          puts "[PindoContext] 缓存未启用，跳过文件缓存加载"
+        elsif @file_cache_loaded
+          puts "[PindoContext] 文件缓存已加载，跳过重复加载"
+        end
       end
+      puts "[PindoContext] ======================================\n"
     end
 
     # 重置上下文（顶层命令结束时调用）
     def reset_context
-      # 保存文件缓存
-      save_file_cache if @current_command && !@is_nested_call
+      # 仅在启用缓存时保存文件缓存
+      save_file_cache if @cache_enabled && @current_command
 
       @current_command = nil
       @current_directory = nil
-      @is_nested_call = false
       @file_cache_loaded = false
+      @cache_enabled = false
+      @command_group = nil
       # 暂不清理内存缓存，让同一进程内可以复用
     end
 
-    # 设置用户选择
+    # 设置用户选择（三级结构：项目路径 -> 根命令 -> 键值）
     def set_selection(key, value)
-      context_key = get_context_key
-      return unless context_key
+      # 构建三级键 - 使用统一的项目路径获取方法
+      project_path = get_project_path
+      root_command = @command_group || @current_command
+
+      # 如果没有有效的项目路径或命令，不保存
+      unless project_path && root_command
+        puts "[PindoContext] 警告: 无法保存选择，缺少项目路径或命令上下文"
+        return
+      end
+
+      # 初始化三级结构（总是保存到内存，不管是否启用缓存）
+      @memory_selections[project_path] ||= {}
+      @memory_selections[project_path][root_command] ||= {}
+      @memory_selections[project_path][root_command][key] = value
 
-      @memory_selections[context_key] ||= {}
-      @memory_selections[context_key][key] = value
+      # 更新该命令组的最后修改时间
+      @memory_selections[project_path][root_command]['__last_modified__'] = Time.now.to_i
 
-      # 立即保存到文件缓存
-      save_file_cache
+      puts "[PindoContext] 保存到内存: [#{project_path}][#{root_command}][#{key}] = #{value.inspect}"
 
-      if ENV['PINDO_DEBUG']
-        puts "[PindoContext] 记录选择: #{key} = #{value.inspect}"
+      # 仅在启用缓存时保存到文件
+      if @cache_enabled
+        save_file_cache
+        puts "[PindoContext] 已保存到文件缓存"
+      else
+        puts "[PindoContext] 缓存未启用，仅保存到内存"
       end
     end
 
-    # 获取用户选择
+    # 获取用户选择（三级结构访问）
     def get_selection(key)
-      context_key = get_context_key
-      return nil unless context_key
+      # 使用统一的项目路径获取方法
+      project_path = get_project_path
+      root_command = @command_group || @current_command
+
+      return nil unless project_path && root_command
 
-      value = @memory_selections[context_key] && @memory_selections[context_key][key]
+      # 从三级结构中获取值（总是从内存获取，不管是否启用缓存）
+      value = @memory_selections.dig(project_path, root_command, key)
 
-      if value && ENV['PINDO_DEBUG']
-        puts "[PindoContext] 使用缓存: #{key} = #{value.inspect}"
+      if value
+        puts "[PindoContext] 从内存获取: [#{project_path}][#{root_command}][#{key}] = #{value.inspect}"
+      else
+        puts "[PindoContext] 内存中未找到: [#{project_path}][#{root_command}][#{key}]" if ENV['PINDO_DEBUG']
       end
 
       value
@@ -86,18 +124,82 @@ module Pindo
 
     # 检查是否有缓存的选择
     def has_selection?(key)
+      # 总是检查内存中是否有值，不管是否启用缓存
       !get_selection(key).nil?
     end
 
+    # 启用/禁用缓存
+    def enable_cache(enabled = true)
+      @cache_enabled = enabled
+      if enabled && !@file_cache_loaded && @current_command
+        load_file_cache_with_confirmation
+        @file_cache_loaded = true
+      end
+    end
+
+    # 检查缓存是否启用
+    def cache_enabled?
+      @cache_enabled
+    end
+
     # 是否是嵌套调用
     def nested_call?
-      @is_nested_call
+      !@current_command.nil?
+    end
+
+    # 是否是顶层命令（非嵌套）
+    def top_level_command?
+      @current_command.nil?
+    end
+
+    # 获取当前根命令
+    def root_command
+      @command_group || @current_command
+    end
+
+    # 获取当前项目路径（统一的获取方法，确保一致性）
+    def project_path
+      get_project_path
+    end
+
+    # 内部使用的项目路径获取方法
+    # 优先使用已设置的目录，如果没有则尝试获取Git仓库根目录
+    def get_project_path
+      # 如果已经设置了目录，直接返回
+      return @current_directory if @current_directory
+
+      # 尝试获取Git仓库根目录
+      begin
+        git_root = `git rev-parse --show-toplevel 2>/dev/null`.strip
+        return git_root if $?.success? && !git_root.empty?
+      rescue
+        # git命令失败
+      end
+
+      # 最后的后备：使用当前目录
+      Dir.pwd
+    end
+
+    # 清除当前上下文的缓存
+    def clear_current_cache
+      return unless @cache_enabled
+
+      proj_path = get_project_path
+      cmd = root_command
+      return unless proj_path && cmd
+
+      if @memory_selections[proj_path] && @memory_selections[proj_path][cmd]
+        @memory_selections[proj_path].delete(cmd)
+        @memory_selections.delete(proj_path) if @memory_selections[proj_path].empty?
+        save_file_cache
+        puts "[PindoContext] 清除缓存: [#{proj_path}][#{cmd}]" if ENV['PINDO_DEBUG']
+      end
     end
 
     # 选择键定义
     module SelectionKey
       TAG_DECISION = :tag_decision      # 打Tag决定
-      APP_KEY = :app_key                # 项目名称/App代号
+      PROJECT_NAME = :project_name      # 项目名称
       BUNDLE_ID = :bundle_id            # Bundle ID
       CERT_TYPE = :cert_type            # 证书类型
     end
@@ -116,35 +218,65 @@ module Pindo
       File.join(cache_dir, 'context_selections.json')
     end
 
-    # 加载文件缓存并确认
+    # 加载文件缓存并确认（三级结构）
     def load_file_cache_with_confirmation
       file_path = cache_file_path
-      return unless File.exist?(file_path)
+
+      puts "[PindoContext] 检查文件缓存: #{file_path}"
+
+      unless File.exist?(file_path)
+        puts "[PindoContext] 文件缓存不存在，跳过加载"
+        return
+      end
 
       begin
         file_content = File.read(file_path)
         file_cache = JSON.parse(file_content)
 
-        # 获取当前上下文的缓存
-        context_key = get_context_key
-        cached_selections = file_cache[context_key]
+        # 清理过期缓存（超过7天）
+        file_cache = clean_expired_cache(file_cache)
+
+        # 获取当前项目和命令的缓存
+        project_path = get_project_path
+        root_command = @command_group || @current_command
+
+        puts "[PindoContext] 查找缓存: [#{project_path}][#{root_command}]"
+
+        # 检查三级结构中是否有当前上下文的缓存
+        cached_selections = file_cache.dig(project_path, root_command)
 
         if cached_selections && !cached_selections.empty?
-          # 显示缓存的选择
-          puts "\n检测到之前的选择:"
+          # 根据命令组显示更友好的描述
+          group_desc = case root_command
+                       when 'ios:autobuild'
+                         'iOS 构建'
+                       when 'and:autobuild', 'android:autobuild'
+                         'Android 构建'
+                       when 'web:autobuild'
+                         'Web 构建'
+                       else
+                         @current_command  # 其他命令显示原始命令名
+                       end
+
+          puts "\n检测到之前的选择 (#{group_desc}):"
           puts "────────────────────────────────────────"
 
           cached_selections.each do |key, value|
-            case key
-            when 'bundle_id', :bundle_id
+            # 跳过内部字段
+            next if key.to_s.start_with?('__')
+
+            case key.to_s
+            when 'bundle_id'
               puts "  Bundle ID: #{value}"
-            when 'app_key', :app_key
-              puts "  App代号: #{value}"
-            when 'tag_decision', :tag_decision
+            when 'project_name', 'app_key'  # 兼容旧的 app_key
+              puts "  项目名称: #{value}"
+            when 'tag_decision'
               if value.is_a?(Hash)
                 action_desc = value['description'] || value['action']
                 puts "  Tag决定: #{action_desc}"
               end
+            when 'cert_type'
+              puts "  证书类型: #{value}"
             end
           end
           puts "────────────────────────────────────────"
@@ -156,29 +288,41 @@ module Pindo
 
           if confirm
             puts "使用缓存的选择\n"
-            # 合并文件缓存到内存缓存
-            file_cache.each do |ctx_key, selections|
-              @memory_selections[ctx_key] ||= {}
-              selections.each do |key, value|
-                symbol_key = key.to_sym
-                @memory_selections[ctx_key][symbol_key] = value
+            # 恢复三级结构的文件缓存到内存缓存
+            file_cache.each do |proj_path, commands|
+              @memory_selections[proj_path] ||= {}
+              commands.each do |cmd, selections|
+                @memory_selections[proj_path][cmd] ||= {}
+                selections.each do |key, value|
+                  symbol_key = key.to_sym
+                  @memory_selections[proj_path][cmd][symbol_key] = value
+                end
               end
             end
           else
             puts "清除缓存，重新选择\n"
-            # 清除当前上下文的文件缓存
-            file_cache.delete(context_key)
+            # 清除当前上下文的文件缓存（三级结构）
+            if file_cache[project_path] && file_cache[project_path][root_command]
+              file_cache[project_path].delete(root_command)
+              # 如果项目路径下没有任何命令缓存了，删除项目路径键
+              file_cache.delete(project_path) if file_cache[project_path].empty?
+            end
             File.write(file_path, JSON.pretty_generate(file_cache))
             # 不加载任何缓存到内存
           end
         else
-          # 加载其他上下文的缓存（不需要确认）
-          file_cache.each do |ctx_key, selections|
-            next if ctx_key == context_key  # 跳过当前上下文（已经是空的）
-            @memory_selections[ctx_key] ||= {}
-            selections.each do |key, value|
-              symbol_key = key.to_sym
-              @memory_selections[ctx_key][symbol_key] = value
+          # 加载整个文件缓存到内存（不需要确认）
+          file_cache.each do |proj_path, commands|
+            @memory_selections[proj_path] ||= {}
+            commands.each do |cmd, selections|
+              # 跳过当前上下文（已经是空的）
+              next if proj_path == project_path && cmd == root_command
+
+              @memory_selections[proj_path][cmd] ||= {}
+              selections.each do |key, value|
+                symbol_key = key.to_sym
+                @memory_selections[proj_path][cmd][symbol_key] = value
+              end
             end
           end
         end
@@ -189,19 +333,22 @@ module Pindo
       end
     end
 
-    # 保存文件缓存
+    # 保存文件缓存（三级结构）
     def save_file_cache
       file_path = cache_file_path
 
       begin
-        # 转换内存缓存为可序列化的格式
+        # 转换内存缓存为可序列化的格式（保持三级结构）
         file_cache = {}
-        @memory_selections.each do |context_key, selections|
-          file_cache[context_key] = {}
-          selections.each do |key, value|
-            # 将符号键转换为字符串
-            string_key = key.to_s
-            file_cache[context_key][string_key] = value
+        @memory_selections.each do |project_path, commands|
+          file_cache[project_path] ||= {}
+          commands.each do |command, selections|
+            file_cache[project_path][command] ||= {}
+            selections.each do |key, value|
+              # 将符号键转换为字符串
+              string_key = key.to_s
+              file_cache[project_path][command][string_key] = value
+            end
           end
         end
 
@@ -214,42 +361,112 @@ module Pindo
       end
     end
 
-    # 命令归一化，将相关命令映射到同一组
-    def normalize_command(command)
+    # 获取命令组名称（统一管理命令缓存组）
+    def get_command_group(command)
+      # 根据需求文档定义命令组，相关命令共享同一缓存
       case command
-      when 'ios:autobuild', 'unity:ipa'
-        'ios_build_group'
-      when 'android:autobuild', 'android:build', 'unity:apk'
-        'android_build_group'
-      when 'unity:webgl'
-        'webgl_build_group'
+      # iOS 构建相关命令组
+      when 'unity:ipa'
+        'ios:autobuild'
+
+      # Android 构建相关命令组
+      when 'unity:apk'
+        'and:autobuild'
+
+      # Web 构建相关命令组
+      when 'unity:web'
+        'web:autobuild'
+
       else
-        command
+        command  # 其他命令使用独立缓存（命令名本身作为组）
       end
     end
 
-    # 生成上下文键
-    def get_context_key
-      return nil unless @current_command
+    # 清理过期缓存（超过7天的缓存）
+    def clean_expired_cache(cache_data)
+      return {} unless cache_data.is_a?(Hash)
+
+      current_time = Time.now.to_i
+      seven_days_in_seconds = 7 * 24 * 60 * 60
+      cleaned_cache = {}
+      expired_commands = []
+      expired_projects = []
+
+      cache_data.each do |project_path, commands|
+        # 初始化项目路径
+        cleaned_commands = {}
+
+        commands.each do |command, selections|
+          # 获取最后修改时间
+          last_modified = selections['__last_modified__']
+
+          # 如果没有时间戳，视为过期
+          if last_modified.nil?
+            expired_commands << "[#{project_path}][#{command}] (无时间戳)"
+            puts "[PindoContext] 清理无时间戳缓存: [#{project_path}][#{command}]" if ENV['PINDO_DEBUG']
+            next
+          end
+
+          # 检查是否过期（超过7天）
+          if (current_time - last_modified.to_i) > seven_days_in_seconds
+            days_old = (current_time - last_modified.to_i) / (24 * 60 * 60)
+            expired_commands << "[#{project_path}][#{command}] (#{days_old}天前)"
+            puts "[PindoContext] 清理过期缓存 (#{days_old}天前): [#{project_path}][#{command}]" if ENV['PINDO_DEBUG']
+            next
+          end
+
+          # 保留未过期的缓存
+          cleaned_commands[command] = selections
+        end
+
+        # 如果该项目路径下还有有效的命令缓存，保留它
+        if cleaned_commands.any?
+          cleaned_cache[project_path] = cleaned_commands
+        else
+          # 整个项目路径下的所有命令都过期了，删除整个项目路径
+          expired_projects << project_path
+          puts "[PindoContext] 删除空项目路径: #{project_path}" if ENV['PINDO_DEBUG']
+        end
+      end
+
+      # 输出清理总结
+      if expired_commands.any? || expired_projects.any?
+        puts "[PindoContext] 缓存清理完成:"
+        if expired_commands.any?
+          puts "  - 清理了 #{expired_commands.size} 个过期命令缓存"
+          expired_commands.each { |cmd| puts "    • #{cmd}" } if ENV['PINDO_DEBUG']
+        end
+        if expired_projects.any?
+          puts "  - 删除了 #{expired_projects.size} 个空项目路径"
+          expired_projects.each { |proj| puts "    • #{proj}" } if ENV['PINDO_DEBUG']
+        end
 
-      # 使用命令组和目录哈希作为键
-      dir_hash = Digest::MD5.hexdigest(@current_directory || Dir.pwd)[0..7]
-      "#{@current_command}:#{dir_hash}"
+        # 立即保存清理后的缓存到文件
+        File.write(cache_file_path, JSON.pretty_generate(cleaned_cache))
+      end
+
+      cleaned_cache
     end
 
+
     public
 
     # 调试信息
     def debug_info
       puts "\n=== PindoContext Debug Info ==="
       puts "当前命令: #{@current_command || '无'}"
-      puts "当前目录: #{@current_directory || Dir.pwd}"
-      puts "是否嵌套: #{@is_nested_call}"
-      puts "上下文键: #{get_context_key || '无'}"
+      puts "命令组: #{@command_group || '无'}"
+      puts "设置的目录: #{@current_directory || '未设置'}"
+      puts "实际项目路径: #{get_project_path}"
+      puts "缓存启用: #{@cache_enabled}"
+
+      proj_path = get_project_path
+      root_cmd = @command_group || @current_command
 
-      if @memory_selections[get_context_key]
+      if root_cmd && @memory_selections.dig(proj_path, root_cmd)
         puts "当前缓存的选择:"
-        @memory_selections[get_context_key].each do |k, v|
+        @memory_selections[proj_path][root_cmd].each do |k, v|
+          next if k.to_s.start_with?('__')  # 跳过内部字段
           puts "  #{k}: #{v.inspect}"
         end
       end

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

@@ -14,6 +14,12 @@ module Pindo
         include Pindo::Githelper
 
         self.summary = '打包Android工程并发布到蒲公英'
+
+        # 启用缓存机制
+        def self.use_cache?
+          true  # 此命令启用缓存
+        end
+
         self.description = <<-DESC
           编译Android包并支持上传到测试平台。
 

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

@@ -12,11 +12,18 @@ module Pindo
     class Command
         class Ios < Command
             class Autobuild < Ios
-        
+
                 include Appselect
                 include Pindo::Githelper
                 # 命令的简要说明 - 打包iOS工程并发布到蒲公英
                 self.summary = '打包iOS工程并发布到蒲公英'
+
+                # 启用缓存机制
+                def self.use_cache?
+                    true  # 此命令启用缓存
+                end
+                # 缓存组已在 PindoContext#get_command_group 中定义
+                # ios:autobuild 与 unity:ipa 共享 'ios:autobuild' 缓存组
     
                 # 命令的详细说明,包含用法示例
                 self.description = <<-DESC
@@ -84,10 +91,6 @@ module Pindo
                 def run
                     pindo_project_dir = Dir.pwd
 
-                    # 设置 PindoContext 上下文
-                    context = Pindo::PindoContext.instance
-                    context.set_context('ios:autobuild', pindo_project_dir)
-
                     build_helper = Pindo::BuildHelper.share_instance
                     project_type = build_helper.project_type(pindo_project_dir)
 

data/lib/pindo/command/ios/build.rb

@@ -13,6 +13,13 @@ module Pindo
                 # 命令的简要说明 - 编译iOS工程并可选择上传到测试平台
                 self.summary = '编译iOS工程,并支持上传ipa'
 
+                # 启用缓存机制
+                def self.use_cache?
+                    true  # 此命令启用缓存
+                end
+                # 缓存组已在 PindoContext#get_command_group 中定义
+                # ios:build 与 ios:autobuild 共享 'ios:autobuild' 缓存组
+
                 # 命令的详细说明,包含用法示例
                 self.description = <<-DESC
                     编译iOS工程并生成ipa文件。

data/lib/pindo/command/unity/apk.rb

@@ -14,6 +14,11 @@ module Pindo
                 # 命令的简要说明 - 编译Unity工程生成Android APK
                 self.summary = '编译Unity工程生成Android APK'
 
+                # 启用缓存机制
+                def self.use_cache?
+                    true  # 此命令启用缓存
+                end
+
                 # 命令的详细说明,包含用法示例
                 self.description = <<-DESC
                     编译Unity工程生成Android APK。

data/lib/pindo/command/unity/ipa.rb

@@ -13,11 +13,18 @@ module Pindo
             class Ipa < Unity
 
                 include Appselect
-                
+
                 include Pindo::Githelper
                 # Unity IPA包编译和上传命令
                 self.summary = '编译Unity工程生成iOS IPA并支持上传到测试平台'
 
+                # 启用缓存机制
+                def self.use_cache?
+                    true  # 此命令启用缓存
+                end
+                # 缓存组已在 PindoContext#get_command_group 中定义
+                # unity:ipa 与 ios:autobuild 共享 'ios:autobuild' 缓存组
+
                 # 详细说明
                 self.description = <<-DESC
                     编译Unity工程生成iOS IPA并支持上传到测试平台。
@@ -158,9 +165,10 @@ module Pindo
                     if @args_send_flag
                         args_temp << "--send"
                     end
-                    
+
+
                     Dir.chdir(pindo_ios_project_dir)
-                    
+
                     Pindo::Command::Ios::Autobuild::run(args_temp)
 
 

data/lib/pindo/command/unity/web.rb

@@ -14,30 +14,35 @@ module Pindo
                 include Appselect
                 
                 include Pindo::Githelper
-                # Unity IPA包编译和上传命令
-                self.summary = '编译Unity工程生成iOS IPA并支持上传到测试平台'
+                # Unity WebGL包编译和上传命令
+                self.summary = '编译Unity工程生成WebGL并支持上传到测试平台'
+
+                # 启用缓存机制
+                def self.use_cache?
+                    true  # 此命令启用缓存
+                end
 
                 # 详细说明
                 self.description = <<-DESC
-                    编译Unity工程生成iOS IPA并支持上传到测试平台。
+                    编译Unity工程生成WebGL并支持上传到测试平台。
                     
                     支持功能:
 
-                        * 编译生成IPA
+                        * 编译生成WebGL
 
-                        * 上传到测试平台  
+                        * 上传到测试平台
 
                         * 发送测试通知
 
                     使用示例:
 
-                        $ pindo unity ipa                    # 编译IPA
+                        $ pindo unity web                    # 编译WebGL
 
-                        $ pindo unity ipa --upload           # 编译并上传
+                        $ pindo unity web --upload           # 编译并上传
 
-                        $ pindo unity ipa --send             # 编译上传并发送通知
+                        $ pindo unity web --send             # 编译上传并发送通知
 
-                        $ pindo unity ipa --proj=myapp       # 指定项目名称
+                        $ pindo unity web --proj=myapp       # 指定项目名称
                 DESC
 
                 # 命令参数
@@ -49,7 +54,7 @@ module Pindo
                 def self.options
                     [
                         ['--proj',   '指定上传到测试平台的项目名称'],
-                        ['--upload', '上传编译后的IPA到测试平台'],
+                        ['--upload', '上传编译后的WebGL到测试平台'],
                         ['--send',   '上传成功后发送测试通知'],
                         ['--base',   'Unity工程编译lib模式'],
                         ['--unity-version', '切换Unity版本']

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

@@ -16,6 +16,11 @@ module Pindo
 
                 self.summary = '打包Unity WebGL包'
 
+                # 启用缓存机制
+                def self.use_cache?
+                    true  # 此命令启用缓存
+                end
+
                 # 命令的详细说明,包含用法示例
                 self.description = <<-DESC
                     编译WebGL包并支持上传到测试平台。

data/lib/pindo/command.rb

@@ -60,6 +60,13 @@ module Pindo
         self.version = VERSION
         self.description = 'pindo, make it easy!'
 
+        # 缓存配置：子类可以重写此方法来启用缓存
+        def self.use_cache?
+          false  # 默认不使用缓存
+        end
+        # 注意：缓存组的定义已经移至 PindoContext#get_command_group 中统一管理
+        # 使用命令名作为组名，如 ios:autobuild, and:autobuild, web:autobuild
+
 
         DEFAULT_ROOT_OPTIONS = [
           ['--version', '查看pindo版本'],
@@ -90,23 +97,62 @@ module Pindo
         end
 
         def self.run(argv)
-            # 设置上下文
-            context = Pindo::PindoContext.instance
-            command_name = self.command  # 获取完整的命令名称，如 'ios:autobuild'
-            context.set_context(command_name)
-
-            begin
-                result = super(argv)
-            ensure
-                # 确保在命令结束时重置上下文
-                context.reset_context
-            end
-            result
+            # 直接调用父类的 run 方法
+            # PindoContext 的设置在 initialize 中处理
+            super(argv)
         end
 
         def initialize(argv)
             super
             @args_help_flag = argv.flag?('help', false)
+
+            # 在非抽象命令初始化时设置上下文
+            if !self.class.abstract_command? && !@args_help_flag
+                context = Pindo::PindoContext.instance
+
+                # 只在上下文未设置时才设置（避免重复设置）
+                if context.instance_variable_get(:@current_command).nil?
+                    # 获取完整的命令路径
+                    command_parts = []
+                    current = self.class
+                    while current < Pindo::Command
+                        if current.command && current.command != 'pindo'
+                            command_parts.unshift(current.command)
+                        end
+                        current = current.superclass
+                    end
+                    command_name = command_parts.empty? ? self.class.command : command_parts.join(':')
+
+                    # 配置选项
+                    cache_enabled_value = self.class.respond_to?(:use_cache?) ? self.class.use_cache? : false
+                    options = {
+                        cache_enabled: cache_enabled_value
+                    }
+
+                    # 获取项目根目录（Git仓库根目录或当前目录）
+                    project_dir = get_project_root_directory(Dir.pwd)
+
+                    context.set_context(command_name, project_dir, options)
+                end
+            end
+        end
+
+        private
+
+        # 获取项目根目录（优先使用Git仓库根目录）
+        def get_project_root_directory(current_dir)
+            # 尝试获取Git仓库根目录
+            begin
+                git_root = `cd "#{current_dir}" && git rev-parse --show-toplevel 2>/dev/null`.strip
+                if $?.success? && !git_root.empty?
+                    return git_root
+                end
+            rescue
+                # git命令失败，继续使用当前目录
+            end
+
+            # 如果不是Git仓库，返回当前目录
+            current_dir
         end
 
     end

data/lib/pindo/module/android/android_build_config_helper.rb

@@ -263,8 +263,9 @@ module Pindo
                     activities.each do |activity|
                         intent_filters = activity.xpath("intent-filter")
                         intent_filters.each do |intent_filter|
-                            has_main = intent_filter.xpath("action[@android:name='android.intent.action.MAIN']").any?
-                            has_launcher = intent_filter.xpath("category[@android:name='android.intent.category.LAUNCHER']").any?
+                            # 修复：移除命名空间后，应该使用 @name 而不是 @android:name
+                            has_main = intent_filter.xpath("action[@name='android.intent.action.MAIN']").any?
+                            has_launcher = intent_filter.xpath("category[@name='android.intent.category.LAUNCHER']").any?
 
                             if has_main && has_launcher
                                 best_manifest = manifest_path
@@ -277,6 +278,7 @@ module Pindo
                     end
                 rescue => e
                     # 静默处理解析错误，继续尝试下一个文件
+                    puts "解析 #{manifest_path} 时出错: #{e.message}" if ENV['PINDO_DEBUG']
                 end
 
                 break if best_activity
@@ -290,8 +292,8 @@ module Pindo
             scheme_exists = false
             existing_scheme = nil
 
-            # 首先检查完全一致的scheme
-            activity.xpath("intent-filter/data[@#{android_prefix}:scheme='#{scheme_name}']").each do |node|
+            # 首先检查完全一致的scheme（修复：移除命名空间后使用 @scheme）
+            activity.xpath("intent-filter/data[@scheme='#{scheme_name}']").each do |node|
                 scheme_exists = true
                 existing_scheme = scheme_name
                 break
@@ -299,8 +301,8 @@ module Pindo
 
             # 如果没有找到完全一致的，检查可能格式不同的scheme
             if !scheme_exists
-                activity.xpath("intent-filter/data[@#{android_prefix}:scheme]").each do |node|
-                    current_scheme = node["#{android_prefix}:scheme"]
+                activity.xpath("intent-filter/data[@scheme]").each do |node|
+                    current_scheme = node["scheme"]
                     normalized_current = current_scheme.to_s.downcase.strip.gsub(/[\s\-_]/, '')
 
                     if normalized_current == scheme_name

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

@@ -389,7 +389,7 @@ module Pindo
         additional_args = {}
         additional_args[:platform] = platform if platform
         additional_args[:buildtype] = 'library' if isLibrary
-        
+
         # 首先尝试使用GoodUnityBuild.BuildManager.BatchBuild
         result = execute_unity_command(unity_exe_full_path, project_path, additional_args)
 
@@ -537,7 +537,6 @@ module Pindo
       # 解析Unity进程信息
       def parse_unity_processes(processes_output, unity_exe_full_path: nil, project_path: nil)
         processes = []
-        current_pid = Process.pid.to_s
 
         processes_output.lines.each do |line|
           # 解析 ps aux 输出格式
@@ -546,14 +545,14 @@ module Pindo
             pid = parts[1]
             command = parts[10..-1].join(' ')
 
-            # 过滤掉grep进程本身、pindo进程和当前进程
-            unless command.include?('grep') || command.include?('pindo') || pid == current_pid
+            # 过滤掉grep进程本身和pindo进程
+            unless command.include?('grep') || command.include?('pindo')
               # 精确匹配Unity进程
               is_relevant_unity_process = false
               match_reasons = []
 
               # 1. 必须是Unity Editor主进程（排除VS Code等其他进程）
-              is_unity_editor = command.match?(/Unity\.app.*\/Unity/i) || command.match?(/Unity\.exe$/i)
+              is_unity_editor = command.match?(/Unity\.app.*\/Unity/i) || command.match?(/Unity\.exe/i)
 
               if is_unity_editor
                 # 2. 检查是否是打开了指定项目的Unity进程

data/lib/pindo/module/pgyer/pgyerhelper.rb

@@ -108,7 +108,7 @@ module Pindo
                 # 检查缓存的 App Key
                 require_relative '../../base/pindocontext'
                 context = Pindo::PindoContext.instance
-                cached_app_key = context.get_selection(Pindo::PindoContext::SelectionKey::APP_KEY)
+                cached_app_key = context.get_selection(Pindo::PindoContext::SelectionKey::PROJECT_NAME)
 
                 if cached_app_key && proj_name_array.include?(cached_app_key)
                     puts "\n使用之前选择的App代号: #{cached_app_key}"
@@ -135,7 +135,7 @@ module Pindo
 
                     # 保存选择到缓存（排除自定义输入选项）
                     if upload_proj_name && !upload_proj_name.include?("自定义输入")
-                        context.set_selection(Pindo::PindoContext::SelectionKey::APP_KEY, upload_proj_name)
+                        context.set_selection(Pindo::PindoContext::SelectionKey::PROJECT_NAME, upload_proj_name)
                     end
                 end
 

data/lib/pindo/version.rb

@@ -6,7 +6,7 @@ require 'time'
 
 module Pindo
 
-  VERSION = "5.3.7"
+  VERSION = "5.4.0"
 
   class VersionCheck
     RUBYGEMS_API = 'https://rubygems.org/api/v1/gems/pindo.json'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: pindo
 version: !ruby/object:Gem::Version
-  version: 5.3.7
+  version: 5.4.0
 platform: ruby
 authors:
 - wade
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: claide
@@ -457,7 +457,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.6.3
 specification_version: 3
 summary: easy work
 test_files: []