ukiryu 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1cb7b872cb1bf64055841e0a8d278b1b57f97fe7bf2133a52067eeee8d51f9f
-  data.tar.gz: 200175ef0a1a88d193396363b8a6335a01ed8d3a91863d660b25767f86abab4a
+  metadata.gz: '09496e921523ef4d99248688fee0293e542ff1cbfc7759403e062822d843f9ba'
+  data.tar.gz: 3e094dc9c7af3313d3d3e5d6179a491b037ce643ecf79d00715c5c6099f7b3e2
 SHA512:
-  metadata.gz: b3a7ed29941fab82a1b5b055a246234245ae7ba7c50d6d779b107b5a64d567bdbc4a71b3480182aab57831ab0a3119c36e71fa273157ace8b6f316c6ea11467b
-  data.tar.gz: 03f7e09b741cb05f4a0188511326438671d48a54444441d8abb2d15dfb969afd2ca6eb435dc1b9f0c893bb5015cf8c44b5131cf778c2e8d06062d6ba22e3aafc
+  metadata.gz: d357286b89e3edaa8a495f965146effd6ffe06250f8f378c1e38ca6eef8d349abbe1698648e986c6bde2be52ff57637433ef6360175172e171d9db6155856fc4
+  data.tar.gz: b3cd0be008011acc0f659b77b651163b61af823e63af3e68486acdc82beb82d074b6a0cb84a21ea299c813e1c201d3089123dc83e687a3366f12ce3cd10318b6

data/lib/ukiryu/cache.rb

@@ -50,6 +50,12 @@ module Ukiryu
       @mutex = Mutex.new if thread_safe
     end
 
+    # @return [Integer] maximum cache size
+    attr_reader :max_size
+
+    # @return [Integer, nil] time-to-live in seconds
+    attr_reader :ttl
+
     # Get a value from the cache
     #
     # @param key [Object] the cache key

data/lib/ukiryu/cache_registry.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Ukiryu
+  # Centralized cache registry for managing all Ukiryu caches.
+  #
+  # Provides a single point of control for:
+  # - Clearing all caches (useful for testing)
+  # - Getting cache statistics (useful for debugging)
+  # - Accessing individual caches by name
+  #
+  # @example Clear all caches
+  #   Ukiryu::CacheRegistry.clear_all
+  #
+  # @example Get cache statistics
+  #   Ukiryu::CacheRegistry.stats
+  #   # => { tool_cache: { size: 10, hits: 100, misses: 5 }, ... }
+  #
+  module CacheRegistry
+    class << self
+      # Get all registered caches
+      #
+      # @return [Array<Cache>] list of cache instances
+      def caches
+        [
+          ToolCache.cache,
+          Definition::Loader.profile_cache
+        ].compact
+      end
+
+      # Clear all registered caches
+      #
+      # @return [void]
+      def clear_all
+        caches.each(&:clear)
+        nil
+      end
+
+      # Get statistics for all caches
+      #
+      # @return [Hash] cache name => stats hash
+      def stats
+        {
+          tool_cache: cache_stats(ToolCache.cache),
+          definition_cache: cache_stats(Definition::Loader.profile_cache)
+        }.compact
+      end
+
+      private
+
+      # Get stats for a single cache
+      #
+      # @param cache [Cache, nil] the cache instance
+      # @return [Hash, nil] stats hash or nil if cache is nil
+      def cache_stats(cache)
+        return nil unless cache
+
+        {
+          size: cache.size,
+          max_size: cache.max_size
+        }
+      end
+    end
+  end
+end

data/lib/ukiryu/cli_commands/base_command.rb

@@ -36,7 +36,9 @@ module Ukiryu
         register_path = custom_path || config.register || default_register_path
         return unless register_path && Dir.exist?(register_path)
 
-        Ukiryu::Register.default_register_path = register_path
+        # Set UKIRYU_REGISTER env and reset the default register
+        ENV['UKIRYU_REGISTER'] = register_path
+        Ukiryu::Register.reset_default
       end
 
       # Apply CLI options to the Config instance
@@ -80,11 +82,10 @@ module Ukiryu
 
       # Get the default register path
       #
-      # @return [String, nil] the default register path from RegisterAutoManager
+      # @return [String, nil] the default register path
       def default_register_path
-        # Use RegisterAutoManager to find or create the register
-        Ukiryu::RegisterAutoManager.register_path
-      rescue StandardError
+        Ukiryu::Register.default.path
+      rescue Ukiryu::Register::Error
         nil
       end
 

data/lib/ukiryu/cli_commands/config_command.rb

@@ -222,23 +222,20 @@ module Ukiryu
       #
       # @return [String] formatted register display
       def format_register_display
-        info = Ukiryu::RegisterAutoManager.register_info
+        register = Ukiryu::Register.default
+        info = register.info
 
-        case info[:status]
-        when :ok
-          # Register exists and is valid
+        if info[:valid]
           source_label = format_source_label(info[:source])
           tools_count = info[:tools_count] ? " (#{info[:tools_count]} tools)" : ''
           "#{info[:path]} [#{source_label}]#{tools_count}"
-        when :not_cloned, :not_found
-          # Register not cloned yet
-          '~/.ukiryu/register (not found - run: ukiryu register update)'
-        when :invalid
-          # Register exists but is invalid
+        elsif info[:exists]
           "#{info[:path]} (invalid - run: ukiryu register update --force)"
         else
-          '(unknown)'
+          '~/.ukiryu/register (not found - run: ukiryu register update)'
         end
+      rescue Ukiryu::Register::Error
+        '~/.ukiryu/register (not found - run: ukiryu register update)'
       end
 
       # Format source label for display

data/lib/ukiryu/cli_commands/register_command.rb

@@ -21,7 +21,7 @@ module Ukiryu
         else
           error!("Unknown subcommand: #{subcommand}. Valid subcommands: info, update, path")
         end
-      rescue Ukiryu::RegisterAutoManager::RegisterError => e
+      rescue Ukiryu::Register::Error => e
         error!("Register error: #{e.message}")
       end
 
@@ -31,21 +31,16 @@ module Ukiryu
       #
       # @param options [Hash] command options
       def show_info(_options = {})
-        info = Ukiryu::RegisterAutoManager.register_info
+        info = Ukiryu::Register.default.info
 
         say 'Register Information', :cyan
         say ''
 
-        case info[:status]
+        case determine_status(info)
         when :not_found
           say '  Status: Not configured', :red
           say ''
           say '  No register found. Run: ukiryu register update', :yellow
-        when :not_cloned
-          say '  Status: Not cloned', :yellow
-          say "  Expected path: #{info[:path]}", :dim
-          say ''
-          say '  Run: ukiryu register update', :yellow
         when :invalid
           say '  Status: Invalid', :red
           say "  Path: #{info[:path]}", :dim
@@ -58,11 +53,14 @@ module Ukiryu
 
           say "  Tools available: #{info[:tools_count]}", :dim if info[:tools_count]
 
-          say "  Branch: #{info[:branch]}", :dim if info[:branch]
-
-          say "  Commit: #{info[:commit]}", :dim if info[:commit]
-
-          say "  Last updated: #{info[:last_update].strftime('%Y-%m-%d %H:%M:%S')}", :dim if info[:last_update]
+          if info[:git_info]
+            say "  Branch: #{info[:git_info][:branch]}", :dim if info[:git_info][:branch]
+            say "  Commit: #{info[:git_info][:commit]}", :dim if info[:git_info][:commit]
+            if info[:git_info][:last_update]
+              say "  Last updated: #{info[:git_info][:last_update].strftime('%Y-%m-%d %H:%M:%S')}",
+                  :dim
+            end
+          end
         end
 
         say ''
@@ -74,7 +72,15 @@ module Ukiryu
           say '  UKIRYU_REGISTER (not set)', :dim
         end
 
-        show_manual_setup_help if info[:status] != :ok
+        show_manual_setup_help unless info[:valid]
+      end
+
+      # Determine register status from info hash
+      def determine_status(info)
+        return :not_found unless info[:exists]
+        return :invalid unless info[:valid]
+
+        :ok
       end
 
       # Update the register
@@ -85,11 +91,14 @@ module Ukiryu
 
         if force
           say 'Force re-cloning register...', :yellow
+          FileUtils.rm_rf(Ukiryu::Register.default.path) if Dir.exist?(Ukiryu::Register.default.path)
+          Ukiryu::Register.reset_default
         else
           say 'Updating register...', :cyan
         end
 
-        Ukiryu::RegisterAutoManager.update_register(force: force)
+        register = Ukiryu::Register.default
+        register.update!
 
         say 'Register updated successfully!', :green
         show_info(options)
@@ -97,9 +106,9 @@ module Ukiryu
 
       # Show the register path
       def show_path
-        path = Ukiryu::RegisterAutoManager.register_path
+        path = Ukiryu::Register.default.path
 
-        if path
+        if path && Dir.exist?(path)
           say path
         else
           error!('Register not available. Run: ukiryu register update')
@@ -129,7 +138,7 @@ module Ukiryu
         say 'Manual setup:', :cyan
         say ''
         say '  1. Clone the register:'
-        say "     git clone #{Ukiryu::RegisterAutoManager::REGISTER_URL} ~/.ukiryu/register"
+        say '     git clone https://github.com/ukiryu/register ~/.ukiryu/register'
         say ''
         say '  2. Or set environment variable:'
         say '     export UKIRYU_REGISTER=/path/to/register'

data/lib/ukiryu/cli_commands/validate_command.rb

@@ -163,7 +163,7 @@ module Ukiryu
       #
       # This method runs executable validation against all tool definitions
       def test_all_executables
-        register_path = Ukiryu::RegisterAutoManager.register_path
+        register_path = Ukiryu::Register.default.path
         return say_error("Register not found: #{register_path}") unless Dir.exist?(register_path)
 
         tools_dir = File.join(register_path, 'tools')
@@ -453,7 +453,7 @@ module Ukiryu
 
       # Validate all definitions in register
       def validate_all
-        register_path = Ukiryu::RegisterAutoManager.register_path
+        register_path = Ukiryu::Register.default.path
         return say_error("Register not found: #{register_path}") unless Dir.exist?(register_path)
 
         tools_dir = File.join(register_path, 'tools')

data/lib/ukiryu/command_builder.rb

@@ -17,11 +17,10 @@ module Ukiryu
     def build_args(command, params)
       args = []
 
-      # Debug logging for Ruby 4.0 CI - log all params
-      if ENV['UKIRYU_DEBUG_EXECUTABLE']
-        warn "[UKIRYU DEBUG CommandBuilder#build_args] params: #{params.inspect}"
-        warn "[UKIRYU DEBUG CommandBuilder#build_args] params.class: #{params.class}"
-      end
+      # Debug logging for CI - log all params
+      Logger.debug("command: #{command.name}", category: :executable)
+      Logger.debug("params: #{params.inspect}", category: :executable)
+      Logger.debug("params.class: #{params.class}", category: :executable)
 
       # Add subcommand prefix if present (e.g., for ImageMagick "magick convert")
       args << command.subcommand if command.subcommand
@@ -45,6 +44,11 @@ module Ukiryu
         next if params[param_key].nil?
 
         formatted_opt = format_option(opt_def, params[param_key])
+
+        # Debug logging
+        Logger.debug("formatted_opt for #{param_key}: #{formatted_opt.inspect}",
+                     category: :executable)
+
         Array(formatted_opt).each { |opt| args << opt unless opt.nil? || opt.empty? }
       end
 
@@ -65,12 +69,11 @@ module Ukiryu
       last_arg = arguments.find(&:last?)
       regular_args = arguments.reject(&:last?)
 
-      # Debug logging for Ruby 4.0 CI - log arguments
-      if ENV['UKIRYU_DEBUG_EXECUTABLE']
-        warn "[UKIRYU DEBUG CommandBuilder#build_args] arguments: #{arguments.inspect}"
-        warn "[UKIRYU DEBUG CommandBuilder#build_args] regular_args: #{regular_args.map(&:name_sym).inspect}"
-        warn "[UKIRYU DEBUG CommandBuilder#build_args] last_arg: #{last_arg&.name_sym.inspect}"
-      end
+      # Debug logging for arguments
+      Logger.debug("arguments: #{arguments.inspect}", category: :executable)
+      Logger.debug("regular_args: #{regular_args.map(&:name_sym).inspect}",
+                   category: :executable)
+      Logger.debug("last_arg: #{last_arg&.name_sym.inspect}", category: :executable)
 
       # Add regular positional arguments (in order, excluding "last")
       regular_args.sort_by(&:numeric_position).each do |arg_def|
@@ -80,21 +83,17 @@ module Ukiryu
         value = params[param_key]
         next if value.nil?
 
-        # Debug logging for Ruby 4.0 CI
-        if ENV['UKIRYU_DEBUG_EXECUTABLE']
-          warn "[UKIRYU DEBUG CommandBuilder#build_args] param_key: #{param_key.inspect}"
-          warn "[UKIRYU DEBUG CommandBuilder#build_args] value.class: #{value.class}"
-          warn "[UKIRYU DEBUG CommandBuilder#build_args] value.inspect: #{value.inspect}"
-          warn "[UKIRYU DEBUG CommandBuilder#build_args] arg_def.variadic: #{arg_def.variadic}"
-        end
+        # Debug logging
+        Logger.debug("param_key: #{param_key.inspect}", category: :executable)
+        Logger.debug("value.class: #{value.class}", category: :executable)
+        Logger.debug("value.inspect: #{value.inspect}", category: :executable)
+        Logger.debug("arg_def.variadic: #{arg_def.variadic}", category: :executable)
 
         if arg_def.variadic
           # Variadic argument - expand array
           array = Ukiryu::Type.validate(value, :array, arg_def)
-          if ENV['UKIRYU_DEBUG_EXECUTABLE']
-            warn "[UKIRYU DEBUG CommandBuilder#build_args] array.class: #{array.class}"
-            warn "[UKIRYU DEBUG CommandBuilder#build_args] array.inspect: #{array.inspect}"
-          end
+          Logger.debug("array.class: #{array.class}", category: :executable)
+          Logger.debug("array.inspect: #{array.inspect}", category: :executable)
           array.each { |v| args << format_arg(v, arg_def) }
         else
           args << format_arg(value, arg_def)
@@ -124,11 +123,12 @@ module Ukiryu
         end
       end
 
-      # Debug logging for Ruby 4.0 CI
-      if ENV['UKIRYU_DEBUG_EXECUTABLE']
-        warn "[UKIRYU DEBUG CommandBuilder#build_args] Built args: #{args.inspect}"
-        warn "[UKIRYU DEBUG CommandBuilder#build_args] Args class: #{args.class}"
-        warn "[UKIRYU DEBUG CommandBuilder#build_args] Args size: #{args.size}"
+      # Debug logging for final args
+      Logger.debug("Final args: #{args.inspect}", category: :executable)
+      Logger.debug("Args class: #{args.class}", category: :executable)
+      Logger.debug("Args size: #{args.size}", category: :executable)
+      args.each_with_index do |arg, i|
+        Logger.debug("args[#{i}]: #{arg.inspect} (#{arg.class})", category: :executable)
       end
 
       args
@@ -144,7 +144,7 @@ module Ukiryu
       Ukiryu::Type.validate(value, arg_def.type || :string, arg_def)
 
       # Apply platform-specific path formatting
-      if arg_def.type == :file
+      if arg_def.type.to_s == 'file'
         shell = Ukiryu::Shell::InstanceCache.instance_for(@shell)
         shell.format_path(value.to_s)
       else
@@ -161,6 +161,13 @@ module Ukiryu
       # Validate type
       Ukiryu::Type.validate(value, opt_def.type || :string, opt_def)
 
+      # Debug logging - trace the full option formatting
+      Logger.debug("opt_def.name: #{opt_def.name.inspect}", category: :executable)
+      Logger.debug("opt_def.cli: #{opt_def.cli.inspect}", category: :executable)
+      Logger.debug("opt_def.assignment_delimiter: #{opt_def.assignment_delimiter.inspect}",
+                   category: :executable)
+      Logger.debug("value: #{value.inspect} (#{value.class})", category: :executable)
+
       # Handle boolean types - just return the CLI flag (no value)
       type_val = opt_def.type
       if [:boolean, TrueClass, 'boolean'].include?(type_val)
@@ -173,27 +180,55 @@ module Ukiryu
       delimiter_sym = opt_def.assignment_delimiter_sym
       separator = opt_def.separator || '='
 
+      Logger.debug("cli variable: #{cli.inspect}", category: :executable)
+      Logger.debug("delimiter_sym: #{delimiter_sym.inspect}", category: :executable)
+
       # Auto-detect delimiter based on CLI prefix
       delimiter_sym = detect_delimiter(cli) if delimiter_sym == :auto
 
-      # Convert value to string (handle symbols)
-      value_str = value.is_a?(Symbol) ? value.to_s : value.to_s
+      Logger.debug("delimiter_sym after detect: #{delimiter_sym.inspect}",
+                   category: :executable)
+
+      # Convert value to string (handle symbols and file paths)
+      if value.is_a?(Symbol)
+        value_str = value.to_s
+      elsif opt_def.type.to_s == 'file'
+        # Apply platform-specific path formatting for file types
+        shell_instance = Ukiryu::Shell::InstanceCache.instance_for(@shell)
+        Logger.debug("FILE type detected: opt_def.name=#{opt_def.name}, value=#{value.inspect}",
+                     category: :executable)
+        Logger.debug("@shell=#{@shell.inspect}, shell_instance=#{shell_instance.class}",
+                     category: :executable)
+        Logger.debug("Platform.windows?=#{Ukiryu::Platform.windows? if defined?(Ukiryu::Platform)}",
+                     category: :executable)
+        value_str = shell_instance.format_path(value.to_s)
+        Logger.debug("format_path result: #{value_str.inspect}", category: :executable)
+      else
+        value_str = value.to_s
+      end
 
       # Handle array values with separator
       if value.is_a?(Array) && separator
-        joined = value.join(separator)
-        case delimiter_sym
-        when :equals
-          "#{cli}=#{joined}"
-        when :space
-          [cli, joined] # Return array for space-separated
-        when :colon
-          "#{cli}:#{joined}"
-        when :none
-          cli
-        else
-          "#{cli}=#{joined}"
-        end
+        # Apply path formatting to each element if type is file
+        formatted_values = if opt_def.type.to_s == 'file'
+                             shell_instance ||= Ukiryu::Shell::InstanceCache.instance_for(@shell)
+                             value.map { |v| shell_instance.format_path(v.to_s) }
+                           else
+                             value.map(&:to_s)
+                           end
+        joined = formatted_values.join(separator)
+        result = case delimiter_sym
+                 when :equals
+                   "#{cli}=#{joined}"
+                 when :space
+                   [cli, joined] # Return array for space-separated
+                 when :colon
+                   "#{cli}:#{joined}"
+                 when :none
+                   cli
+                 else
+                   "#{cli}=#{joined}"
+                 end
       else
         result = case delimiter_sym
                  when :equals
@@ -207,15 +242,13 @@ module Ukiryu
                  else
                    "#{cli}=#{value_str}"
                  end
+      end
 
-        # Debug logging for Ruby 3.4+ CI
-        if ENV['UKIRYU_DEBUG_EXECUTABLE']
-          warn "[UKIRYU DEBUG format_option] result: #{result.inspect}"
-          warn "[UKIRYU DEBUG format_option] result.class: #{result.class}"
-        end
+      # Debug logging for result
+      Logger.debug("FINAL result: #{result.inspect}", category: :executable)
+      Logger.debug("result.class: #{result.class}", category: :executable)
 
-        result
-      end
+      result
     end
 
     # Detect assignment delimiter based on CLI prefix

data/lib/ukiryu/config.rb

@@ -33,7 +33,9 @@ module Ukiryu
 
     class << self
       def instance
-        @instance ||= new
+        mutex.synchronize do
+          @instance ||= new
+        end
       end
 
       # Configure Ukiryu with a block
@@ -46,7 +48,9 @@ module Ukiryu
 
       # Reset configuration to defaults
       def reset!
-        @instance = new
+        mutex.synchronize do
+          @instance = new
+        end
       end
 
       # Delegate to instance
@@ -57,6 +61,13 @@ module Ukiryu
       def respond_to_missing?(method, include_private = false)
         instance.respond_to?(method) || super
       end
+
+      private
+
+      # Mutex for thread-safe singleton access
+      def mutex
+        @mutex ||= Mutex.new
+      end
     end
 
     # @!attribute [r] resolver

data/lib/ukiryu/debug.rb

@@ -12,24 +12,35 @@ module Ukiryu
   #
   # @example Disable debug logging (default)
   #   Ukiryu.debug_enabled? # => false
+  #
+  # @example Log with category
+  #   Ukiryu::Debug.log("Found executable", category: :executable)
   module Debug
     class << self
-      # Check if debug logging is enabled
-      #
-      # Debug is enabled ONLY when UKIRYU_DEBUG environment variable is set.
-      # The ENV['CI'] check was removed to prevent debug output from polluting
-      # JSON/YAML output in automated tests.
+      # Check if debug logging is enabled for a category
       #
+      # @param category [Symbol, nil] the category (:executable for UKIRYU_DEBUG_EXECUTABLE)
       # @return [Boolean] true if debug mode is enabled
-      def enabled?
-        ENV['UKIRYU_DEBUG'] || ENV['UKIRYU_DEBUG_EXECUTABLE']
+      def enabled?(category = nil)
+        case category
+        when :executable
+          ENV['UKIRYU_DEBUG_EXECUTABLE'] || (defined?(Platform) && Platform.windows? && ENV['CI'])
+        else
+          ENV['UKIRYU_DEBUG'] || ENV['UKIRYU_DEBUG_EXECUTABLE']
+        end
       end
 
       # Log a debug message to stderr
       #
       # @param message [String] the debug message
-      def log(message)
-        warn "[UKIRYU DEBUG] #{message}" if enabled?
+      # @param category [Symbol, nil] optional category (:executable for executable discovery)
+      # @param context [Hash] optional context data
+      def log(message, category: nil, context: {})
+        return unless enabled?(category)
+
+        prefix = "[UKIRYU DEBUG#{category ? " #{category.to_s.upcase}" : ''}]"
+        details = context.empty? ? '' : " (#{context.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')})"
+        warn "#{prefix} #{message}#{details}"
       end
     end
   end

data/lib/ukiryu/definition/loader.rb

@@ -60,11 +60,11 @@ module Ukiryu
           load_from_source(source, options)
         end
 
-        # Get the profile cache
+        # Get the profile cache (bounded LRU cache)
         #
-        # @return [Hash] the profile cache
+        # @return [Cache] the profile cache
         def profile_cache
-          @profile_cache ||= {}
+          @profile_cache ||= Cache.new(max_size: 100, ttl: 3600)
         end
 
         # Clear the profile cache