ukiryu 0.1.1 → 0.1.3

data/lib/ukiryu/command_builder.rb

@@ -2,6 +2,7 @@
 
 require_relative 'type'
 require_relative 'shell'
+require_relative 'models/env_var_definition'
 
 module Ukiryu
   # CommandBuilder module provides shared command building functionality.
@@ -23,7 +24,19 @@ module Ukiryu
       # Add subcommand prefix if present (e.g., for ImageMagick "magick convert")
       args << command.subcommand if command.subcommand
 
-      # Add options first (before arguments)
+      # Add prefix flags FIRST (must come before any options)
+      command.flags&.each do |flag_def|
+        param_key = flag_def.name_sym
+        next unless flag_def.position_constraint_sym == :prefix
+
+        value = params[param_key]
+        value = flag_def.default if value.nil?
+
+        formatted_flag = format_flag(flag_def, value)
+        Array(formatted_flag).each { |flag| args << flag unless flag.nil? || flag.empty? }
+      end
+
+      # Add options (after prefix flags)
       command.options&.each do |opt_def|
         param_key = opt_def.name_sym
         next unless params.key?(param_key)
@@ -33,9 +46,11 @@ module Ukiryu
         Array(formatted_opt).each { |opt| args << opt unless opt.nil? || opt.empty? }
       end
 
-      # Add flags
+      # Add non-prefix flags (after options)
       command.flags&.each do |flag_def|
         param_key = flag_def.name_sym
+        next if flag_def.position_constraint_sym == :prefix
+
         value = params[param_key]
         value = flag_def.default if value.nil?
 
@@ -127,43 +142,59 @@ module Ukiryu
       end
 
       cli = opt_def.cli || ''
-      format_sym = opt_def.format_sym
+      delimiter_sym = opt_def.assignment_delimiter_sym
       separator = opt_def.separator || '='
 
+      # 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
 
       # Handle array values with separator
       if value.is_a?(Array) && separator
         joined = value.join(separator)
-        case format_sym
-        when :double_dash_equals
-          "#{cli}#{joined}"
-        when :double_dash_space, :single_dash_space
+        case delimiter_sym
+        when :equals
+          "#{cli}=#{joined}"
+        when :space
           [cli, joined] # Return array for space-separated
-        when :single_dash_equals
-          "#{cli}#{joined}"
+        when :colon
+          "#{cli}:#{joined}"
+        when :none
+          cli
         else
-          "#{cli}#{joined}"
+          "#{cli}=#{joined}"
         end
       else
-        case format_sym
-        when :double_dash_equals
-          "#{cli}#{separator}#{value_str}"
-        when :double_dash_space, :single_dash_space
+        case delimiter_sym
+        when :equals
+          "#{cli}=#{value_str}"
+        when :space
           [cli, value_str] # Return array for space-separated
-        when :single_dash_equals
-          "#{cli}#{separator}#{value_str}"
-        when :slash_colon
+        when :colon
           "#{cli}:#{value_str}"
-        when :slash_space
-          "#{cli} #{value_str}"
+        when :none
+          cli
         else
-          "#{cli}#{separator}#{value_str}"
+          "#{cli}=#{value_str}"
         end
       end
     end
 
+    # Detect assignment delimiter based on CLI prefix
+    #
+    # @param cli [String] the CLI flag
+    # @return [Symbol] the delimiter
+    def detect_delimiter(cli)
+      case cli
+      when /^--/ then :equals   # --flag=value
+      when /^-/ then :space     # -f value
+      when %r{^/} then :colon # /format:value
+      else :equals
+      end
+    end
+
     # Format a flag
     #
     # @param flag_def [Models::FlagDefinition] the flag definition
@@ -178,11 +209,38 @@ module Ukiryu
     # Build environment variables for command
     #
     # @param command [Models::CommandDefinition] the command definition
+    # @param profile [Models::PlatformProfile] the profile (for env_var_sets)
     # @param params [Hash] the parameters hash
     # @return [Hash] the environment variables hash
-    def build_env_vars(command, params)
+    def build_env_vars(command, profile, params)
       env_vars = {}
 
+      # First, add env vars from sets specified in use_env_vars
+      command.use_env_vars&.each do |set_name|
+        set = profile.env_var_sets&.dig(set_name.to_s)
+        next unless set
+
+        set.each do |ev_data|
+          # Convert hash to EnvVarDefinition if needed
+          ev = ev_data.is_a?(Hash) ? Models::EnvVarDefinition.new(ev_data) : ev_data
+
+          # Check platform restriction
+          platforms = ev.platforms || []
+          next if platforms.any? && !platforms.map(&:to_sym).include?(@platform)
+
+          # Get value - use ev.value if provided, or extract from params
+          value = if ev.value
+                    ev.value
+                  elsif ev.from
+                    params[ev.from.to_sym]
+                  end
+
+          # Set the environment variable if value is defined (including empty string)
+          env_vars[ev.name] = value.to_s unless value.nil?
+        end
+      end
+
+      # Then, add command's own env_vars (can override set values)
       command.env_vars&.each do |ev|
         # Check platform restriction
         platforms = ev.platforms || []
@@ -191,8 +249,8 @@ module Ukiryu
         # Get value - use ev.value if provided, or extract from params
         value = if ev.value
                   ev.value
-                elsif ev.env_var
-                  params[ev.env_var.to_sym]
+                elsif ev.from
+                  params[ev.from.to_sym]
                 end
 
         # Set the environment variable if value is defined (including empty string)

data/lib/ukiryu/config/env_provider.rb

@@ -40,9 +40,9 @@ module Ukiryu
           load_attributes(EnvSchema.all_output_attributes)
         end
 
-        # Load registry-specific environment overrides
-        def load_registry
-          load_attributes(EnvSchema.all_registry_attributes)
+        # Load register-specific environment overrides
+        def load_register
+          load_attributes(EnvSchema.all_register_attributes)
         end
 
         private

data/lib/ukiryu/config/env_schema.rb

@@ -17,8 +17,8 @@ module Ukiryu
         format: :symbol,
         output: :string,
 
-        # Registry options
-        registry: :string,
+        # Register options
+        register: :string,
 
         # Tool discovery options
         search_paths: :string, # Comma-separated paths
@@ -48,14 +48,14 @@ module Ukiryu
           %i[format output use_color]
         end
 
-        # All registry attributes
-        def all_registry_attributes
-          %i[registry search_paths]
+        # All register attributes
+        def all_register_attributes
+          %i[register search_paths]
         end
 
         # All attributes
         def all_attributes
-          %i[timeout debug dry_run metrics shell format output registry search_paths use_color]
+          %i[timeout debug dry_run metrics shell format output register search_paths use_color]
         end
       end
     end

data/lib/ukiryu/config.rb

@@ -129,16 +129,16 @@ module Ukiryu
       @resolver.set_programmatic(:output, value)
     end
 
-    # Registry path
-    # @return [String, nil] path to tool registry
-    def registry
-      @resolver.resolve(:registry)
+    # Register path
+    # @return [String, nil] path to tool register
+    def register
+      @resolver.resolve(:register)
     end
 
-    # Set registry path
-    # @param value [String] path to tool registry
-    def registry=(value)
-      @resolver.set_programmatic(:registry, value)
+    # Set register path
+    # @param value [String] path to tool register
+    def register=(value)
+      @resolver.set_programmatic(:register, value)
     end
 
     # Tool search paths (comma-separated)
@@ -214,7 +214,7 @@ module Ukiryu
         shell: shell,
         format: format,
         output: output,
-        registry: registry,
+        register: register,
         search_paths: search_paths,
         use_color: use_color
       }
@@ -231,9 +231,9 @@ module Ukiryu
         shell: nil,
         format: :yaml,
         output: nil,
-        registry: nil,
+        register: nil,
         search_paths: nil,
-        use_color: nil # nil means auto-detect
+        use_color: nil
       }
 
       env = EnvProvider.load_all

data/lib/ukiryu/definition/definition_cache.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require 'digest'
+require_relative 'metadata'
+
+module Ukiryu
+  module Definition
+    # Cache for tool definitions with hot-reload support
+    #
+    # This class provides caching for tool definitions with automatic
+    # invalidation based on file modification time and TTL.
+    class DefinitionCache
+      # Default cache TTL in seconds (5 minutes)
+      DEFAULT_TTL = 300
+
+      # Cache entry structure
+      class Entry
+        attr_reader :definition, :mtime, :loaded_at, :source_key
+
+        def initialize(definition, mtime: nil, source_key: nil)
+          @definition = definition
+          @mtime = mtime
+          @loaded_at = Time.now
+          @source_key = source_key || generate_source_key(definition)
+        end
+
+        # Check if entry is stale
+        #
+        # @param ttl [Integer] time to live in seconds
+        # @return [Boolean] true if entry is stale
+        def stale?(ttl: DEFAULT_TTL)
+          # Check TTL
+          return true if Time.now - @loaded_at > ttl
+
+          # Check mtime for file-based definitions
+          if @mtime && @definition.respond_to?(:path)
+            path = @definition.path
+            return true if path && File.exist?(path) && File.mtime(path) > @mtime
+          end
+
+          false
+        end
+
+        # Refresh the entry
+        #
+        # @return [Entry] refreshed entry
+        def refresh
+          if @definition.respond_to?(:load_definition)
+            # Reload from metadata
+            new_def = @definition.load_definition
+            Entry.new(new_def, mtime: new_def.mtime, source_key: @source_key)
+          else
+            # Can't refresh, return as-is
+            self
+          end
+        end
+
+        private
+
+        def generate_source_key(definition)
+          # Generate cache key from definition
+          if definition.respond_to?(:name) && definition.respond_to?(:version)
+            Digest::SHA256.hexdigest("#{definition.name}/#{definition.version}")
+          else
+            Digest::SHA256.hexdigest(definition.object_id.to_s)
+          end
+        end
+      end
+
+      # Singleton instance
+      @instance = nil
+
+      class << self
+        # Get the singleton instance
+        #
+        # @return [DefinitionCache] the cache instance
+        def instance
+          @instance ||= new
+        end
+
+        # Reset the singleton (useful for testing)
+        def reset_instance
+          @instance = nil
+        end
+      end
+
+      # Initialize a new cache
+      #
+      # @param ttl [Integer] default time-to-live in seconds
+      def initialize(ttl: DEFAULT_TTL)
+        @cache = {}
+        @ttl = ttl
+        @refresh_strategy = :lazy
+        @mutex = Mutex.new
+      end
+
+      # Get a cached definition
+      #
+      # @param key [String] the cache key
+      # @return [Models::ToolDefinition, nil] the cached definition, or nil
+      def get(key)
+        @mutex.synchronize do
+          entry = @cache[key]
+          return nil unless entry
+
+          # Check staleness
+          if entry.stale?(ttl: @ttl)
+            if @refresh_strategy == :lazy
+              # Refresh and return
+              entry = entry.refresh
+              @cache[key] = entry if entry
+            else
+              # Return stale entry (eager mode refreshes in background)
+            end
+          end
+          entry.definition
+        end
+      end
+
+      # Set a cached definition
+      #
+      # @param key [String] the cache key
+      # @param definition [Models::ToolDefinition] the definition to cache
+      # @param metadata [DefinitionMetadata, nil] optional metadata for mtime tracking
+      # @return [Models::ToolDefinition] the cached definition
+      def set(key, definition, metadata: nil)
+        @mutex.synchronize do
+          mtime = metadata&.mtime
+          entry = Entry.new(definition, mtime: mtime)
+          @cache[key] = entry
+          definition
+        end
+      end
+
+      # Check if a key exists in cache
+      #
+      # @param key [String] the cache key
+      # @return [Boolean] true if key exists
+      def key?(key)
+        @cache.key?(key)
+      end
+
+      # Invalidate a cache entry
+      #
+      # @param key [String] the cache key to invalidate
+      # @return [Boolean] true if entry was invalidated
+      def invalidate(key)
+        @mutex.synchronize do
+          !@cache.delete(key).nil?
+        end
+      end
+
+      # Clear all cache entries
+      #
+      # @return [Integer] number of entries cleared
+      def clear
+        @mutex.synchronize do
+          count = @cache.size
+          @cache.clear
+          count
+        end
+      end
+
+      # Get cache statistics
+      #
+      # @return [Hash] cache statistics
+      def stats
+        {
+          size: @cache.size,
+          ttl: @ttl,
+          refresh_strategy: @refresh_strategy,
+          entries: @cache.keys
+        }
+      end
+
+      # Check if a cache entry is stale
+      #
+      # @param key [String] the cache key
+      # @return [Boolean] true if entry is stale
+      def stale?(key)
+        entry = @cache[key]
+        return true unless entry
+
+        entry.stale?(ttl: @ttl)
+      end
+
+      # Set the refresh strategy
+      #
+      # @param strategy [Symbol] :lazy or :eager
+      def refresh_strategy=(strategy)
+        raise ArgumentError, "Invalid refresh strategy: #{strategy}" unless %i[lazy eager never].include?(strategy)
+
+        @refresh_strategy = strategy
+      end
+
+      # Get the current refresh strategy
+      #
+      # @return [Symbol] the refresh strategy
+      attr_reader :refresh_strategy
+
+      # Set the cache TTL
+      #
+      # @param ttl [Integer] time-to-live in seconds
+
+      # Get the current TTL
+      #
+      # @return [Integer] the TTL in seconds
+      attr_accessor :ttl
+
+      # Refresh all stale entries
+      #
+      # @return [Integer] number of entries refreshed
+      def refresh_stale
+        @mutex.synchronize do
+          count = 0
+          @cache.each do |key, entry|
+            if entry.stale?(ttl: @ttl)
+              @cache[key] = entry.refresh
+              count += 1
+            end
+          end
+          count
+        end
+      end
+
+      # Prune stale entries
+      #
+      # @return [Integer] number of entries pruned
+      def prune
+        @mutex.synchronize do
+          stale_keys = @cache.select { |_, entry| entry.stale?(ttl: @ttl) }.keys
+          stale_keys.each { |key| @cache.delete(key) }
+          stale_keys.size
+        end
+      end
+    end
+  end
+end