ukiryu 0.1.0 → 0.1.1

data/lib/ukiryu/config/type_converter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Ukiryu
+  class Config
+    # Type converter for environment variable values
+    # Converts string ENV values to appropriate Ruby types
+    class TypeConverter
+      BOOLEAN_VALUES = {
+        'true' => true,
+        '1' => true,
+        'yes' => true,
+        'false' => false,
+        '0' => false,
+        'no' => false
+      }.freeze
+
+      class << self
+        def convert(attribute, value)
+          return nil if value.nil? || value.empty?
+
+          type = EnvSchema.type_for(attribute)
+          case type
+          when :boolean
+            convert_boolean(value)
+          when :integer
+            convert_integer(value)
+          when :symbol
+            convert_symbol(value)
+          when :string
+            value
+          else
+            value
+          end
+        end
+
+        private
+
+        def convert_boolean(value)
+          normalized = value.to_s.downcase
+          return BOOLEAN_VALUES[normalized] if BOOLEAN_VALUES.key?(normalized)
+
+          raise ArgumentError,
+                "Invalid boolean value: #{value}. " \
+                "Valid values: #{BOOLEAN_VALUES.keys.join(', ')}"
+        end
+
+        def convert_integer(value)
+          Integer(value)
+        rescue ArgumentError
+          raise ArgumentError, "Invalid integer value: #{value}"
+        end
+
+        def convert_symbol(value)
+          value.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/ukiryu/config.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require_relative 'config/env_provider'
+require_relative 'config/override_resolver'
+
+module Ukiryu
+  # Global configuration for Ukiryu
+  # Provides unified configuration across CLI, Ruby API, and programmatic interfaces
+  #
+  # Configuration priority (highest to lowest):
+  # 1. CLI options (passed at runtime)
+  # 2. Environment variables (UKIRYU_*)
+  # 3. Programmatic configuration (Config.configure)
+  # 4. Default values
+  #
+  # @example Configure programmatically
+  #   Ukiryu::Config.configure do |config|
+  #     config.timeout = 30
+  #     config.debug = true
+  #     config.format = :json
+  #   end
+  #
+  # @example Configure via environment variables
+  #   export UKIRYU_TIMEOUT=60
+  #   export UKIRYU_DEBUG=true
+  #   export UKIRYU_FORMAT=json
+  #
+  # @example Configure via CLI options
+  #   ukiryu exec ping host=example.com --format json --timeout 30
+  class Config
+    class << self
+      def instance
+        @instance ||= new
+      end
+
+      # Configure Ukiryu with a block
+      # @yield [config] The configuration instance
+      # @return [Config] The configuration instance
+      def configure
+        yield instance if block_given?
+        instance
+      end
+
+      # Reset configuration to defaults
+      def reset!
+        @instance = new
+      end
+
+      # Delegate to instance
+      def method_missing(method, ...)
+        instance.send(method, ...)
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        instance.respond_to?(method) || super
+      end
+    end
+
+    # @!attribute [r] resolver
+    #   @return [OverrideResolver] The resolver for configuration values
+    attr_reader :resolver
+
+    def initialize
+      @resolver = build_resolver
+    end
+
+    # Reset configuration to defaults
+    def reset!
+      @resolver = build_resolver
+    end
+
+    # Execution timeout in seconds
+    # @return [Integer, nil] timeout in seconds, or nil for no timeout
+    def timeout
+      @resolver.resolve(:timeout)
+    end
+
+    # Set execution timeout
+    # @param value [Integer] timeout in seconds
+    def timeout=(value)
+      @resolver.set_programmatic(:timeout, value)
+    end
+
+    # Debug mode flag
+    # @return [Boolean] true if debug mode is enabled
+    def debug
+      @resolver.resolve(:debug)
+    end
+
+    # Set debug mode
+    # @param value [Boolean] debug mode flag
+    def debug=(value)
+      @resolver.set_programmatic(:debug, value)
+    end
+
+    # Dry run flag
+    # @return [Boolean] true if dry run is enabled
+    def dry_run
+      @resolver.resolve(:dry_run)
+    end
+
+    # Set dry run mode
+    # @param value [Boolean] dry run flag
+    def dry_run=(value)
+      @resolver.set_programmatic(:dry_run, value)
+    end
+
+    # Output format
+    # @return [Symbol] output format (:yaml, :json, :table)
+    def format
+      @resolver.resolve(:format)
+    end
+
+    # Set output format
+    # @param value [Symbol] output format
+    def format=(value)
+      @resolver.set_programmatic(:format, value)
+    end
+
+    # Output file path
+    # @return [String, nil] output file path, or nil for stdout
+    def output
+      @resolver.resolve(:output)
+    end
+
+    # Set output file path
+    # @param value [String] output file path
+    def output=(value)
+      @resolver.set_programmatic(:output, value)
+    end
+
+    # Registry path
+    # @return [String, nil] path to tool registry
+    def registry
+      @resolver.resolve(:registry)
+    end
+
+    # Set registry path
+    # @param value [String] path to tool registry
+    def registry=(value)
+      @resolver.set_programmatic(:registry, value)
+    end
+
+    # Tool search paths (comma-separated)
+    # @return [String, nil] comma-separated search paths
+    def search_paths
+      @resolver.resolve(:search_paths)
+    end
+
+    # Set search paths
+    # @param value [String] comma-separated search paths
+    def search_paths=(value)
+      @resolver.set_programmatic(:search_paths, value)
+    end
+
+    # Use color in output
+    # @return [Boolean] true if colors should be used
+    def use_color
+      @resolver.resolve(:use_color)
+    end
+
+    # Set color usage
+    # @param value [Boolean] color usage flag
+    def use_color=(value)
+      @resolver.set_programmatic(:use_color, value)
+    end
+
+    # Check if colors are disabled
+    # Returns true if use_color is explicitly false or if NO_COLOR is set
+    # @return [Boolean] true if colors should be disabled
+    def colors_disabled?
+      use_color == false
+    end
+
+    # Metrics collection flag
+    # @return [Boolean] true if metrics should be collected
+    def metrics
+      @resolver.resolve(:metrics)
+    end
+
+    # Set metrics collection
+    # @param value [Boolean] metrics flag
+    def metrics=(value)
+      @resolver.set_programmatic(:metrics, value)
+    end
+
+    # Shell to use for command execution
+    # @return [Symbol, nil] shell symbol (:bash, :zsh, :fish, :powershell, :cmd) or nil for auto-detect
+    def shell
+      @resolver.resolve(:shell)
+    end
+
+    # Set shell
+    # @param value [Symbol, String] shell symbol or string
+    def shell=(value)
+      @resolver.set_programmatic(:shell, value&.to_sym)
+    end
+
+    # Set CLI option (highest priority)
+    # @param key [Symbol] option key
+    # @param value [Object] option value
+    def set_cli_option(key, value)
+      @resolver.set_cli(key, value)
+    end
+
+    # Get configuration as hash
+    # @return [Hash] configuration values
+    def to_h
+      {
+        timeout: timeout,
+        debug: debug,
+        dry_run: dry_run,
+        metrics: metrics,
+        shell: shell,
+        format: format,
+        output: output,
+        registry: registry,
+        search_paths: search_paths,
+        use_color: use_color
+      }
+    end
+
+    private
+
+    def build_resolver
+      defaults = {
+        timeout: nil,
+        debug: false,
+        dry_run: false,
+        metrics: false,
+        shell: nil,
+        format: :yaml,
+        output: nil,
+        registry: nil,
+        search_paths: nil,
+        use_color: nil # nil means auto-detect
+      }
+
+      env = EnvProvider.load_all
+
+      OverrideResolver.new(
+        defaults: defaults,
+        programmatic: {},
+        env: env,
+        cli: {}
+      )
+    end
+  end
+end

data/lib/ukiryu/errors.rb

@@ -17,6 +17,9 @@ module Ukiryu
   class ProfileNotFoundError < Error; end
   class ProfileLoadError < Error; end
 
+  # Definition loading errors
+  class LoadError < Error; end
+
   # Tool errors
   class ToolNotFoundError < Error; end
   class ExecutableNotFoundError < Error; end

data/lib/ukiryu/executable_locator.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative 'executor'
+require_relative 'platform'
+
+module Ukiryu
+  # Executable locator for finding tool executables
+  #
+  # This module provides centralized executable location logic with:
+  # - Custom search paths from tool profiles
+  # - Shell-specific path extensions (Windows PATHEXT)
+  # - Fallback to system PATH
+  # - Proper OOP design (no duplicated code)
+  #
+  # @example Finding an executable
+  #   path = ExecutableLocator.find(
+  #     tool_name: 'imagemagick',
+  #     aliases: ['magick'],
+  #     search_paths: ['/opt/homebrew/bin/magick'],
+  #     platform: :macos
+  #   )
+  module ExecutableLocator
+    class << self
+      # Find an executable by name with search paths
+      #
+      # @param tool_name [String] the primary tool name
+      # @param aliases [Array<String>] alternative names to try
+      # @param search_paths [Array<String>, Models::SearchPaths] custom search paths or SearchPaths model
+      # @param platform [Symbol] the platform (defaults to Runtime.platform)
+      # @return [String, nil] the executable path or nil if not found
+      def find(tool_name:, aliases: [], search_paths: [], platform: nil)
+        platform ||= Runtime.instance.platform
+
+        # Convert SearchPaths model to array if needed
+        paths = normalize_search_paths(search_paths, platform)
+
+        # Try primary name first
+        exe = try_find(tool_name, paths)
+        return exe if exe
+
+        # Try aliases
+        aliases.each do |alias_name|
+          exe = try_find(alias_name, paths)
+          return exe if exe
+        end
+
+        nil
+      end
+
+      # Find an executable in the system PATH
+      #
+      # @param command [String] the command or executable name
+      # @param additional_paths [Array<String>] additional search paths
+      # @return [String, nil] the full path to the executable, or nil if not found
+      def find_in_path(command, additional_paths: [])
+        # Try with PATHEXT extensions (Windows executables)
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+
+        search_paths = Platform.executable_search_paths
+        search_paths.concat(additional_paths) if additional_paths
+        search_paths.uniq!
+
+        search_paths.each do |dir|
+          exts.each do |ext|
+            exe = File.join(dir, "#{command}#{ext}")
+            return exe if File.executable?(exe) && !File.directory?(exe)
+          end
+        end
+
+        nil
+      end
+
+      private
+
+      # Normalize search paths to array format
+      #
+      # @param search_paths [Array<String>, Models::SearchPaths] the search paths
+      # @param platform [Symbol] the platform
+      # @return [Array<String>] normalized array of paths
+      def normalize_search_paths(search_paths, platform)
+        return [] unless search_paths
+
+        # If it's a SearchPaths model, get platform-specific paths
+        return search_paths.for_platform(platform) || [] if search_paths.is_a?(Models::SearchPaths)
+
+        # Already an array
+        search_paths
+      end
+
+      # Try to find an executable by name
+      #
+      # @param command [String] the command name
+      # @param search_paths [Array<String>] custom search paths
+      # @return [String, nil] the executable path or nil
+      def try_find(command, search_paths)
+        # Check custom search paths first (both absolute paths and glob patterns)
+        search_paths.each do |path_pattern|
+          # Handle glob patterns
+          if path_pattern.include?('*')
+            Dir.glob(path_pattern).each do |expanded|
+              return expanded if File.executable?(expanded) && !File.directory?(expanded)
+            end
+          # Handle absolute paths
+          elsif File.executable?(path_pattern) && !File.directory?(path_pattern)
+            return path_pattern
+          end
+        end
+
+        # Fall back to PATH
+        find_in_path(command)
+      end
+    end
+  end
+end

data/lib/ukiryu/execution/command_info.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Ukiryu
+  module Execution
+    # Execution command information
+    #
+    # Encapsulates details about the executed command
+    class CommandInfo
+      attr_reader :executable, :arguments, :full_command, :shell, :tool_name, :command_name
+
+      def initialize(executable:, arguments:, full_command:, shell: nil, tool_name: nil, command_name: nil)
+        @executable = executable
+        @arguments = arguments
+        @full_command = full_command
+        @shell = shell
+        @tool_name = tool_name
+        @command_name = command_name
+      end
+
+      # Get the executable name only
+      #
+      # @return [String] executable name
+      def executable_name
+        File.basename(@executable)
+      end
+
+      # Get argument count
+      #
+      # @return [Integer] number of arguments
+      def argument_count
+        @arguments.count
+      end
+
+      # String representation
+      #
+      # @return [String] command string
+      def to_s
+        @full_command
+      end
+
+      # Inspect
+      #
+      # @return [String] inspection string
+      def inspect
+        "#<Ukiryu::Execution::CommandInfo exe=#{executable_name.inspect} args=#{argument_count}>"
+      end
+
+      # Convert to hash
+      #
+      # @return [Hash] command info as hash
+      def to_h
+        {
+          executable: @executable,
+          executable_name: executable_name,
+          tool_name: @tool_name,
+          command_name: @command_name,
+          arguments: @arguments,
+          full_command: @full_command,
+          shell: @shell
+        }
+      end
+    end
+  end
+end

data/lib/ukiryu/execution/metadata.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Ukiryu
+  module Execution
+    # Execution metadata
+    #
+    # Provides timing and execution environment information
+    class ExecutionMetadata
+      attr_reader :started_at, :finished_at, :duration, :timeout
+
+      def initialize(started_at:, finished_at:, timeout: nil)
+        @started_at = started_at
+        @finished_at = finished_at
+        @timeout = timeout
+        @duration = calculate_duration
+      end
+
+      # Calculate duration from start and finish times
+      #
+      # @return [Float, nil] duration in seconds
+      def calculate_duration
+        return nil unless @started_at && @finished_at
+
+        @finished_at - @started_at
+      end
+
+      # Get execution duration in seconds
+      #
+      # @return [Float, nil] duration in seconds
+      def duration_seconds
+        @duration
+      end
+
+      # Get execution duration in milliseconds
+      #
+      # @return [Float, nil] duration in milliseconds
+      def duration_milliseconds
+        @duration ? @duration * 1000 : nil
+      end
+
+      # Check if execution timed out
+      #
+      # @return [Boolean] true if timeout was set and exceeded
+      def timed_out?
+        return false unless @timeout && @duration
+
+        @duration > @timeout
+      end
+
+      # Format duration for display
+      #
+      # @return [String] formatted duration
+      def formatted_duration
+        return 'N/A' unless @duration
+
+        if @duration < 1
+          "#{(@duration * 1000).round(2)}ms"
+        elsif @duration < 60
+          "#{@duration.round(3)}s"
+        else
+          minutes = @duration / 60
+          seconds = @duration % 60
+          "#{minutes.to_i}m#{seconds.round(1)}s"
+        end
+      end
+
+      # Convert to hash
+      #
+      # @return [Hash] metadata as hash
+      def to_h
+        {
+          started_at: @started_at,
+          finished_at: @finished_at,
+          duration: @duration,
+          duration_seconds: @duration,
+          duration_milliseconds: duration_milliseconds,
+          timeout: @timeout,
+          timed_out: timed_out?
+        }
+      end
+
+      # String representation
+      #
+      # @return [String] formatted string
+      def to_s
+        "duration: #{formatted_duration}"
+      end
+
+      # Inspect
+      #
+      # @return [String] inspection string
+      def inspect
+        "#<Ukiryu::Execution::ExecutionMetadata duration=#{formatted_duration}>"
+      end
+    end
+  end
+end