ukiryu 0.1.0 → 0.1.1

data/lib/ukiryu/cli_commands/validate_command.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+require_relative '../registry'
+require_relative '../models/validation_result'
+
+module Ukiryu
+  module CliCommands
+    # Schema validation command for tool profiles
+    class ValidateCommand < BaseCommand
+      # Execute the validate command
+      #
+      # @param tool_name [String, nil] the tool name (nil to validate all)
+      # @param options [Hash] command options
+      def run(tool_name = nil)
+        setup_registry
+
+        if tool_name
+          validate_single_tool(tool_name)
+        else
+          validate_all_tools
+        end
+      end
+
+      private
+
+      # Validate a single tool
+      #
+      # @param tool_name [String] the tool name
+      def validate_single_tool(tool_name)
+        result = Registry.validate_tool(tool_name, registry_path: config.registry)
+
+        say "Validating tool: #{tool_name}", :cyan
+        say '', :clear
+
+        if result.valid?
+          say result.status_message, :green
+        else
+          say result.status_message, :red
+          say '', :clear
+          result.errors.each do |error|
+            say "  - #{error}", :white
+          end
+        end
+
+        # Exit with error code if validation failed
+        exit(result.invalid? ? 1 : 0)
+      end
+
+      # Validate all tools
+      def validate_all_tools
+        results = Registry.validate_all_tools(registry_path: config.registry)
+
+        say "Validating all tools in registry: #{config.registry}", :cyan
+        say '', :clear
+
+        valid_count = 0
+        invalid_count = 0
+        not_found_count = 0
+
+        results.each do |result|
+          say "#{result.tool_name.ljust(20)}: #{result.status_message}", result.valid? ? :green : :red
+
+          valid_count += 1 if result.valid?
+          invalid_count += 1 if result.invalid? && !result.not_found?
+          not_found_count += 1 if result.not_found?
+
+          # Show errors for invalid tools
+          if result.invalid? && !result.not_found?
+            result.errors.each do |error|
+              say "  - #{error}", :dim
+            end
+          end
+        end
+
+        say '', :clear
+        say "Summary:", :cyan
+        say "  Valid:   #{valid_count}", :green
+        say "  Invalid: #{invalid_count}", invalid_count > 0 ? :red : :white
+        say "  Missing: #{not_found_count}", not_found_count > 0 ? :yellow : :white
+
+        # Exit with error code if any validations failed
+        exit(invalid_count > 0 ? 1 : 0)
+      end
+    end
+  end
+end

data/lib/ukiryu/cli_commands/version_command.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+require_relative '../version'
+
+module Ukiryu
+  module CliCommands
+    # Show Ukiryu version
+    class VersionCommand < BaseCommand
+      # Execute the version command
+      def run
+        say "Ukiryu version #{Ukiryu::VERSION}", :cyan
+      end
+    end
+  end
+end

data/lib/ukiryu/cli_commands/which_command.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+require_relative '../tool'
+require_relative '../platform'
+require_relative '../runtime'
+
+module Ukiryu
+  module CliCommands
+    # Show which tool implementation would be selected
+    class WhichCommand < BaseCommand
+      # Execute the which command
+      #
+      # @param identifier [String] the tool name, interface, or alias
+      def run(identifier)
+        setup_registry
+
+        runtime = Runtime.instance
+        platform = options[:platform] || runtime.platform
+        shell = options[:shell] || runtime.shell
+
+        say '', :clear
+        say "Resolving: #{identifier}", :cyan
+        say "  Platform: #{platform}", :white
+        say "  Shell: #{shell}", :white
+        say '', :clear
+
+        # First try exact name match
+        tool = try_exact_match(identifier, platform, shell)
+
+        # If not found, try interface/alias discovery
+        tool ||= try_interface_discovery(identifier, platform, shell)
+
+        if tool
+          show_selected_tool(tool, identifier, platform, shell)
+        else
+          error! "No tool found for: #{identifier}\nAvailable tools: #{Registry.tools.sort.join(', ')}"
+        end
+      end
+
+      private
+
+      # Try exact name match
+      #
+      # @param identifier [String] the tool name
+      # @param platform [Symbol] the platform
+      # @param shell [Symbol] the shell
+      # @return [Tool, nil] the tool or nil if not found
+      def try_exact_match(identifier, platform, shell)
+        tool = Tool.get(identifier, platform: platform, shell: shell)
+        say 'Match type: Exact name match', :green
+        tool
+      rescue Ukiryu::ToolNotFoundError
+        nil
+      end
+
+      # Try interface/alias discovery
+      #
+      # @param identifier [String] the tool name
+      # @param platform [Symbol] the platform
+      # @param shell [Symbol] the shell
+      # @return [Tool, nil] the tool or nil if not found
+      def try_interface_discovery(identifier, platform, shell)
+        require_relative '../registry'
+
+        candidates = []
+
+        Registry.tools.each do |tool_name|
+          tool_metadata = Registry.load_tool_metadata(tool_name.to_sym)
+          next unless tool_metadata
+
+          # Check for interface match
+          interface_match = tool_metadata.implements == identifier.to_sym
+
+          # Check for alias match
+          alias_match = tool_metadata.aliases&.include?(identifier)
+
+          next unless interface_match || alias_match
+
+          # Check platform compatibility
+          profile = find_compatible_profile(tool_metadata, platform, shell)
+          next unless profile
+
+          match_type = interface_match ? 'interface' : 'alias'
+          candidates << {
+            name: tool_name,
+            metadata: tool_metadata,
+            profile: profile,
+            match_type: match_type
+          }
+        end
+
+        return nil if candidates.empty?
+
+        # Select best candidate (prefer available tools)
+        selected = candidates.find do |c|
+          Tool.get(c[:name], platform: platform, shell: shell).available?
+        end || candidates.first
+
+        say "Match type: #{selected[:match_type]} match", :green
+
+        Tool.get(selected[:name], platform: platform, shell: shell)
+      end
+
+      # Find compatible profile for platform/shell
+      #
+      # @param metadata [ToolMetadata] the tool metadata
+      # @param platform [Symbol] the platform
+      # @param shell [Symbol] the shell
+      # @return [Hash, nil] compatible profile or nil
+      def find_compatible_profile(metadata, platform, shell)
+        require_relative '../tools/generator'
+
+        tool_def = Tools::Generator.load_tool_definition(metadata.name)
+        return nil unless tool_def
+
+        tool_def.compatible_profile(platform: platform, shell: shell)
+      end
+
+      # Show selected tool information
+      #
+      # @param tool [Tool] the selected tool
+      # @param identifier [String] the original identifier
+      # @param platform [Symbol] the platform
+      # @param shell [Symbol] the shell
+      def show_selected_tool(tool, identifier, _platform, _shell)
+        say '', :clear
+        say 'Selected tool:', :yellow
+
+        if tool.name != identifier
+          say "  Query: #{identifier}", :white
+          say "  Resolved to: #{tool.name}", :white
+        else
+          say "  Tool: #{tool.name}", :white
+        end
+
+        # Show implementation info
+        say "  Implements: #{tool.profile.implements}", :white if tool.profile.implements
+
+        # Show profile used
+        profile = tool.instance_variable_get(:@command_profile)
+        if profile
+          say "  Profile: #{profile.name || 'default'}", :white
+
+          # Show profile details
+          platforms = profile.platforms || ['all']
+          shells = profile.shells || ['all']
+          say "    Platforms: #{Array(platforms).join(', ')}", :dim
+          say "    Shells: #{Array(shells).join(', ')}", :dim
+        end
+
+        # Show availability
+        say '', :clear
+        if tool.available?
+          say 'Status: AVAILABLE', :green
+          say "  Executable: #{tool.executable}", :white
+          detected_version = tool.version
+          say "  Version: #{detected_version || 'unknown'}", :white if detected_version
+        else
+          say 'Status: NOT AVAILABLE', :red
+          say '  Tool is not installed or not in PATH', :dim
+        end
+      end
+    end
+  end
+end

data/lib/ukiryu/command_builder.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require_relative 'type'
+require_relative 'shell'
+
+module Ukiryu
+  # CommandBuilder module provides shared command building functionality.
+  #
+  # This module contains methods for building command-line arguments from
+  # command definitions and parameters. It is used by both Tool and
+  # Tools::Base to eliminate code duplication.
+  #
+  # @api private
+  module CommandBuilder
+    # Build command arguments from parameters
+    #
+    # @param command [Models::CommandDefinition] the command definition
+    # @param params [Hash] the parameters hash
+    # @return [Array<String>] the formatted command arguments
+    def build_args(command, params)
+      args = []
+
+      # Add subcommand prefix if present (e.g., for ImageMagick "magick convert")
+      args << command.subcommand if command.subcommand
+
+      # Add options first (before arguments)
+      command.options&.each do |opt_def|
+        param_key = opt_def.name_sym
+        next unless params.key?(param_key)
+        next if params[param_key].nil?
+
+        formatted_opt = format_option(opt_def, params[param_key])
+        Array(formatted_opt).each { |opt| args << opt unless opt.nil? || opt.empty? }
+      end
+
+      # Add flags
+      command.flags&.each do |flag_def|
+        param_key = flag_def.name_sym
+        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
+
+      # Separate "last" positioned argument from other arguments
+      arguments = command.arguments || []
+      last_arg = arguments.find(&:last?)
+      regular_args = arguments.reject(&:last?)
+
+      # Add regular positional arguments (in order, excluding "last")
+      regular_args.sort_by(&:numeric_position).each do |arg_def|
+        param_key = arg_def.name_sym
+        next unless params.key?(param_key)
+
+        value = params[param_key]
+        next if value.nil?
+
+        if arg_def.variadic
+          # Variadic argument - expand array
+          array = Type.validate(value, :array, arg_def)
+          array.each { |v| args << format_arg(v, arg_def) }
+        else
+          args << format_arg(value, arg_def)
+        end
+      end
+
+      # Add post_options (options that come before the "last" argument)
+      command.post_options&.each do |opt_def|
+        param_key = opt_def.name_sym
+        next unless params.key?(param_key)
+        next if params[param_key].nil?
+
+        formatted_opt = format_option(opt_def, params[param_key])
+        Array(formatted_opt).each { |opt| args << opt unless opt.nil? || opt.empty? }
+      end
+
+      # Add the "last" positioned argument (typically output file)
+      if last_arg
+        param_key = last_arg.name_sym
+        if params.key?(param_key) && !params[param_key].nil?
+          if last_arg.variadic
+            array = Type.validate(params[param_key], :array, last_arg)
+            array.each { |v| args << format_arg(v, last_arg) }
+          else
+            args << format_arg(params[param_key], last_arg)
+          end
+        end
+      end
+
+      args
+    end
+
+    # Format a positional argument
+    #
+    # @param value [Object] the argument value
+    # @param arg_def [Models::ArgumentDefinition] the argument definition
+    # @return [String] the formatted argument
+    def format_arg(value, arg_def)
+      # Validate type
+      Type.validate(value, arg_def.type || :string, arg_def)
+
+      # Apply platform-specific path formatting
+      if arg_def.type == :file
+        shell_class = Shell.class_for(@shell)
+        shell_class.new.format_path(value.to_s)
+      else
+        value.to_s
+      end
+    end
+
+    # Format an option
+    #
+    # @param opt_def [Models::OptionDefinition] the option definition
+    # @param value [Object] the option value
+    # @return [String, Array<String>] the formatted option(s)
+    def format_option(opt_def, value)
+      # Validate type
+      Type.validate(value, opt_def.type || :string, opt_def)
+
+      # Handle boolean types - just return the CLI flag (no value)
+      type_val = opt_def.type
+      if [:boolean, TrueClass, 'boolean'].include?(type_val)
+        return nil if value.nil? || value == false
+
+        return opt_def.cli || ''
+      end
+
+      cli = opt_def.cli || ''
+      format_sym = opt_def.format_sym
+      separator = opt_def.separator || '='
+
+      # 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
+          [cli, joined] # Return array for space-separated
+        when :single_dash_equals
+          "#{cli}#{joined}"
+        else
+          "#{cli}#{joined}"
+        end
+      else
+        case format_sym
+        when :double_dash_equals
+          "#{cli}#{separator}#{value_str}"
+        when :double_dash_space, :single_dash_space
+          [cli, value_str] # Return array for space-separated
+        when :single_dash_equals
+          "#{cli}#{separator}#{value_str}"
+        when :slash_colon
+          "#{cli}:#{value_str}"
+        when :slash_space
+          "#{cli} #{value_str}"
+        else
+          "#{cli}#{separator}#{value_str}"
+        end
+      end
+    end
+
+    # Format a flag
+    #
+    # @param flag_def [Models::FlagDefinition] the flag definition
+    # @param value [Object] the flag value
+    # @return [String, nil] the formatted flag
+    def format_flag(flag_def, value)
+      return nil if value.nil? || value == false
+
+      flag_def.cli || ''
+    end
+
+    # Build environment variables for command
+    #
+    # @param command [Models::CommandDefinition] the command definition
+    # @param params [Hash] the parameters hash
+    # @return [Hash] the environment variables hash
+    def build_env_vars(command, params)
+      env_vars = {}
+
+      command.env_vars&.each do |ev|
+        # 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.env_var
+                  params[ev.env_var.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
+
+      env_vars
+    end
+  end
+end

data/lib/ukiryu/config/env_provider.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'env_schema'
+require_relative 'type_converter'
+
+module Ukiryu
+  class Config
+    # Provides environment variable values for configuration
+    # Reads and parses UKIRYU_* environment variables and standard env vars like NO_COLOR
+    class EnvProvider
+      class << self
+        # Load all environment overrides
+        def load_all
+          result = {}
+
+          # Load UKIRYU_* environment variables
+          EnvSchema.all_attributes.each do |attr|
+            env_key = EnvSchema.env_key(attr)
+            value = ENV[env_key]
+
+            # Convert and store if value exists
+            result[attr] = TypeConverter.convert(attr, value) if value
+          end
+
+          # Handle NO_COLOR standard environment variable (https://no-color.org/)
+          # NO_COLOR takes precedence over UKIRYU_USE_COLOR
+          # When set (to any value), colors are disabled
+          result[:use_color] = false if ENV['NO_COLOR']
+
+          result
+        end
+
+        # Load execution-specific environment overrides
+        def load_execution
+          load_attributes(EnvSchema.all_execution_attributes)
+        end
+
+        # Load output-specific environment overrides
+        def load_output
+          load_attributes(EnvSchema.all_output_attributes)
+        end
+
+        # Load registry-specific environment overrides
+        def load_registry
+          load_attributes(EnvSchema.all_registry_attributes)
+        end
+
+        private
+
+        def load_attributes(attributes)
+          result = {}
+          attributes.each do |attr|
+            env_key = EnvSchema.env_key(attr)
+            value = ENV[env_key]
+
+            # Convert and store if value exists
+            result[attr] = TypeConverter.convert(attr, value) if value
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/ukiryu/config/env_schema.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Ukiryu
+  class Config
+    # Schema definition for configuration attributes
+    # Defines attribute types and ENV variable mappings
+    class EnvSchema
+      ATTRIBUTE_TYPES = {
+        # Execution options
+        timeout: :integer,
+        debug: :boolean,
+        dry_run: :boolean,
+        metrics: :boolean,
+        shell: :symbol,
+
+        # Output options
+        format: :symbol,
+        output: :string,
+
+        # Registry options
+        registry: :string,
+
+        # Tool discovery options
+        search_paths: :string, # Comma-separated paths
+
+        # Color options
+        use_color: :boolean
+      }.freeze
+
+      class << self
+        def type_for(attribute)
+          ATTRIBUTE_TYPES[attribute.to_sym]
+        end
+
+        # Generate ENV key for a config attribute
+        # e.g., env_key(:timeout) => "UKIRYU_TIMEOUT"
+        def env_key(attribute)
+          "UKIRYU_#{attribute.to_s.upcase}"
+        end
+
+        # All execution attributes
+        def all_execution_attributes
+          %i[timeout debug dry_run metrics shell]
+        end
+
+        # All output attributes
+        def all_output_attributes
+          %i[format output use_color]
+        end
+
+        # All registry attributes
+        def all_registry_attributes
+          %i[registry search_paths]
+        end
+
+        # All attributes
+        def all_attributes
+          %i[timeout debug dry_run metrics shell format output registry search_paths use_color]
+        end
+      end
+    end
+  end
+end

data/lib/ukiryu/config/override_resolver.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Ukiryu
+  class Config
+    # Resolves configuration values using priority chain
+    # Priority: CLI options > ENV > programmatic > defaults
+    class OverrideResolver
+      attr_reader :defaults, :programmatic, :env, :cli
+
+      def initialize(defaults: {}, programmatic: {}, env: {}, cli: {})
+        @defaults = defaults
+        @programmatic = programmatic
+        @env = env
+        @cli = cli
+      end
+
+      # Resolve a single value using priority chain
+      # Uses .key? to properly handle false values
+      def resolve(key)
+        return @cli[key] if @cli.key?(key)
+        return @env[key] if @env.key?(key)
+        return @programmatic[key] if @programmatic.key?(key)
+
+        @defaults[key]
+      end
+
+      # Update programmatic value
+      def set_programmatic(key, value)
+        @programmatic[key] = value
+      end
+
+      # Update CLI option value
+      def set_cli(key, value)
+        @cli[key] = value
+      end
+
+      # Update ENV override
+      def set_env(key, value)
+        @env[key] = value
+      end
+
+      # Check if value is set by CLI
+      def cli_set?(key)
+        @cli.key?(key)
+      end
+
+      # Check if value is set by ENV
+      def env_set?(key)
+        @env.key?(key)
+      end
+
+      # Check if value is set programmatically
+      def programmatic_set?(key)
+        @programmatic.key?(key)
+      end
+
+      # Get the source of a value
+      def source_for(key)
+        return :cli if @cli.key?(key)
+        return :env if @env.key?(key)
+        return :programmatic if @programmatic.key?(key)
+        return :default if @defaults.key?(key)
+
+        nil
+      end
+    end
+  end
+end