ukiryu 0.1.0 → 0.1.1

data/lib/ukiryu/tool_index.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+# Lazy load ToolMetadata only when needed
+autoload :ToolMetadata, File.expand_path('models/tool_metadata', __dir__)
+
+module Ukiryu
+  # Index for fast tool lookup by interface and alias
+  #
+  # This class maintains cached mappings for:
+  # - Interfaces to tools (multiple tools can implement one interface)
+  # - Aliases to tool names
+  # - Registry change detection via mtime
+  #
+  # Built once and cached for the lifetime of the process.
+  #
+  # @api private
+  class ToolIndex
+    class << self
+      # Get the singleton instance
+      #
+      # @return [ToolIndex] the index instance
+      def instance
+        @instance ||= new
+      end
+
+      # Reset the index (mainly for testing)
+      def reset
+        @instance = nil
+      end
+    end
+
+    # Initialize the index
+    #
+    # @param registry_path [String] the path to the tool registry
+    def initialize(registry_path: Ukiryu::Registry.default_registry_path)
+      @registry_path = registry_path
+      @interface_to_tools = {} # interface => [tool_names]
+      @alias_to_tool = {}      # alias => tool_name
+      @built = false
+      @cache_key = nil        # Registry state for change detection
+    end
+
+    # Find tool metadata by interface name
+    # Returns the first available tool for this interface
+    #
+    # @param interface_name [Symbol] the interface to look up
+    # @return [ToolMetadata, nil] the tool metadata or nil if not found
+    def find_by_interface(interface_name)
+      build_index_if_needed
+
+      tool_names = @interface_to_tools[interface_name]
+      return nil unless tool_names
+
+      # Try each tool implementing this interface until we find one that loads
+      tool_names.each do |tool_name|
+        metadata = load_metadata_for_tool(tool_name)
+        return metadata if metadata
+      end
+
+      nil
+    end
+
+    # Find all tools that implement an interface
+    #
+    # @param interface_name [Symbol] the interface to look up
+    # @return [Array<String>] list of tool names implementing this interface
+    def find_all_by_interface(interface_name)
+      build_index_if_needed
+
+      @interface_to_tools[interface_name] || []
+    end
+
+    # Find tool by alias
+    #
+    # @param alias_name [String] the alias to look up
+    # @return [String, nil] the tool name or nil if not found
+    def find_by_alias(alias_name)
+      build_index_if_needed
+
+      @alias_to_tool[alias_name.to_sym]
+    end
+
+    # Get all tools in the index
+    #
+    # @return [Hash{Symbol => Array<String>}] mapping of interface to tool names
+    def all_tools
+      build_index_if_needed
+
+      @interface_to_tools.dup
+    end
+
+    # Check if the index needs rebuilding due to registry changes
+    #
+    # @return [Boolean] true if rebuild is needed
+    def stale?
+      return true unless @built
+
+      current_cache_key = build_cache_key
+      @cache_key != current_cache_key
+    end
+
+    # Update the registry path
+    #
+    # @param new_path [String] the new registry path
+    def registry_path=(new_path)
+      return if @registry_path == new_path
+
+      @registry_path = new_path
+      @built = false # Rebuild index with new path
+      @cache_key = nil
+      @interface_to_tools = {}
+      @alias_to_tool = {}
+    end
+
+    private
+
+    # Build index only if needed (lazy loading)
+    def build_index_if_needed
+      build_index if stale?
+    end
+
+    # Build cache key for registry change detection
+    # Uses mtime of registry directory + file count for fast comparison
+    #
+    # @return [String] the cache key
+    def build_cache_key
+      current_path = registry_path
+      return 'empty' unless current_path
+
+      tools_dir = File.join(current_path, 'tools')
+      return 'no-tools-dir' unless Dir.exist?(tools_dir)
+
+      # Use directory mtime and file count for change detection
+      mtime = File.mtime(tools_dir).to_s
+      file_count = Dir.glob(File.join(tools_dir, '*', '*.yaml')).size
+
+      "#{mtime}-#{file_count}"
+    end
+
+    # Get the current registry path
+    #
+    # @return [String, nil] the registry path
+    def registry_path
+      @registry_path ||= Ukiryu::Registry.default_registry_path
+    end
+
+    # Build the index by scanning tool directories
+    # This is done once and cached
+    def build_index
+      current_path = registry_path
+      return unless current_path
+
+      tools_dir = File.join(current_path, 'tools')
+      return unless Dir.exist?(tools_dir)
+
+      # Clear existing indexes
+      @interface_to_tools.clear
+      @alias_to_tool.clear
+
+      # Scan all tool directories for metadata
+      Dir.glob(File.join(tools_dir, '*', '*.yaml')).each do |file|
+        # Load only the top-level keys (metadata) without full parsing
+        hash = YAML.safe_load(File.read(file), permitted_classes: [Symbol])
+        next unless hash
+
+        tool_name = File.basename(File.dirname(file))
+        tool_sym = tool_name.to_sym
+
+        # Index by interface (multiple tools can implement one interface)
+        implements = hash['implements']&.to_sym
+        if implements
+          @interface_to_tools[implements] ||= []
+          @interface_to_tools[implements] << tool_sym unless @interface_to_tools[implements].include?(tool_sym)
+        end
+
+        # Index by alias
+        aliases = hash['aliases']
+        if aliases && aliases.respond_to?(:each)
+          aliases.each do |alias_name|
+            @alias_to_tool[alias_name.to_sym] = tool_sym
+          end
+        end
+      rescue StandardError => e
+        # Skip files that can't be parsed
+        warn "Warning: Failed to parse #{file}: #{e.message}"
+      end
+
+      @cache_key = build_cache_key
+      @built = true
+    end
+
+    # Load metadata for a specific tool
+    #
+    # @param tool_name [Symbol, String] the tool name
+    # @return [ToolMetadata, nil] the tool metadata
+    def load_metadata_for_tool(tool_name)
+      yaml_content = load_yaml_for_tool(tool_name)
+      return nil unless yaml_content
+
+      hash = YAML.safe_load(yaml_content, permitted_classes: [Symbol])
+      return nil unless hash
+
+      ToolMetadata.from_hash(hash, tool_name: tool_name.to_s, registry_path: registry_path)
+    end
+
+    # Load YAML content for a specific tool
+    #
+    # @param tool_name [Symbol, String] the tool name
+    # @return [String, nil] the YAML content
+    def load_yaml_for_tool(tool_name)
+      current_path = registry_path
+      return nil unless current_path
+
+      # Search for version files
+      pattern = File.join(current_path, 'tools', tool_name.to_s, '*.yaml')
+      files = Dir.glob(pattern).sort
+
+      # Return the latest version
+      files.last ? File.read(files.last) : nil
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/ukiryu/tools/base.rb

@@ -0,0 +1,381 @@
+# frozen_string_literal: true
+
+require_relative '../runtime'
+require_relative '../command_builder'
+require_relative 'class_generator'
+require_relative 'executable_finder'
+
+module Ukiryu
+  # Tools namespace for tool-specific classes
+  #
+  # This namespace contains dynamically generated classes for each tool,
+  # providing a fully OOP interface for working with command-line tools.
+  #
+  # @example
+  #   Ukiryu::Tools::Imagemagick.new.tap do |tool|
+  #     options = tool.options_for(:convert)
+  #     options.set(inputs: ["image.png"], resize: "50%")
+  #     options.run
+  #   end
+  module Tools
+    # Abstract base class for all tool-specific classes
+    #
+    # This class provides the common interface that all tool classes inherit from.
+    # Tool-specific classes are dynamically generated by Tools::Generator.
+    #
+    # @abstract
+    class Base
+      include Ukiryu::CommandBuilder
+      class << self
+        # Get the tool name symbol
+        #
+        # @return [Symbol] the tool name
+        attr_reader :tool_name
+
+        # Get the tool definition model
+        #
+        # @return [Models::ToolDefinition] the tool definition
+        attr_reader :tool_definition
+
+        # Get the platform profile model
+        #
+        # @return [Models::PlatformProfile] the platform profile
+        attr_reader :platform_profile
+
+        # Get the options class for a specific command
+        #
+        # @param command_name [Symbol] the command name
+        # @return [Class] the options class for this command
+        def options_class_for(command_name)
+          command_name = command_name.to_sym
+          @options_classes ||= {}
+          return @options_classes[command_name] if @options_classes[command_name]
+
+          # Get command from platform profile model
+          command_def = @platform_profile.command(command_name.to_s)
+          raise ArgumentError, "Unknown command: #{command_name}" unless command_def
+
+          # Generate the options class using ClassGenerator
+          options_class = ClassGenerator.generate_options_class(self, command_name, command_def)
+          @options_classes[command_name] = options_class
+          options_class
+        end
+
+        # Alias for options_class_for (more idiomatic)
+        #
+        # @param command_name [Symbol] the command name
+        # @return [Class] the options class for this command
+        def options_for(command_name)
+          options_class_for(command_name)
+        end
+
+        # Get the action class for a specific command
+        #
+        # @param command_name [Symbol] the command name
+        # @return [Class] the action class for this command
+        def action_class_for(command_name)
+          command_name = command_name.to_sym
+          @action_classes ||= {}
+          return @action_classes[command_name] if @action_classes[command_name]
+
+          # Get command from platform profile model
+          command_def = @platform_profile.command(command_name.to_s)
+          raise ArgumentError, "Unknown command: #{command_name}" unless command_def
+
+          # Generate the action class using ClassGenerator
+          action_class = ClassGenerator.generate_action_class(self, command_name, command_def)
+          @action_classes[command_name] = action_class
+          action_class
+        end
+
+        # Alias for action_class_for
+        #
+        # @param command_name [Symbol] the command name
+        # @return [Class] the action class for this command
+        def action_for(command_name)
+          action_class_for(command_name)
+        end
+
+        # Get version information for this tool
+        #
+        # @return [Version, nil] version object if tool is available
+        def version
+          return nil unless available?
+
+          new.version
+        end
+
+        # Check if the tool is available on this system
+        #
+        # @return [Boolean] true if the tool can be executed
+        def available?
+          @available ||= begin
+            executable = ExecutableFinder.find_executable(@tool_definition.name.to_s, @tool_definition)
+            !executable.nil?
+          end
+        end
+
+        # Get the response class for a command
+        #
+        # @param command_name [Symbol] the command name
+        # @return [Class] the response class
+        def response_class_for(command_name)
+          command_name = command_name.to_sym
+          @response_classes ||= {}
+          return @response_classes[command_name] if @response_classes[command_name]
+
+          # Get command from platform profile model
+          command_def = @platform_profile.command(command_name.to_s)
+          raise ArgumentError, "Unknown command: #{command_name}" unless command_def
+
+          # Generate the response class using ClassGenerator
+          response_class = ClassGenerator.generate_response_class(self, command_name, command_def)
+          @response_classes[command_name] = response_class
+          response_class
+        end
+      end
+
+      # Initialize the tool instance
+      #
+      # Sets up shell and platform instance variables for CommandBuilder
+      def initialize
+        runtime = Ukiryu::Runtime.instance
+        @platform = runtime.platform
+        @shell = runtime.shell
+      end
+
+      # Get the tool name for this instance
+      #
+      # @return [Symbol] the tool name
+      def tool_name
+        self.class.tool_name
+      end
+
+      # Get the tool name from the tool definition
+      #
+      # @return [String] the tool name
+      def name
+        self.class.tool_definition.name
+      end
+
+      # Get the tool definition (for backward compatibility)
+      #
+      # @return [Models::ToolDefinition] the tool definition
+      def tool_definition
+        self.class.tool_definition
+      end
+
+      # Get the platform profile (for backward compatibility)
+      #
+      # @return [Models::PlatformProfile] the platform profile
+      def platform_profile
+        self.class.platform_profile
+      end
+
+      # Get a new options instance for a command
+      #
+      # @param command_name [Symbol] the command name
+      # @return [Options::Base] a new options instance
+      def options_for(command_name)
+        self.class.options_for(command_name).new
+      end
+
+      # Get the options class for a command
+      #
+      # @param command_name [Symbol] the command name
+      # @return [Class] the options class
+      def options_class_for(command_name)
+        self.class.options_for(command_name)
+      end
+
+      # Get a new action instance for a command
+      #
+      # @param command_name [Symbol] the command name
+      # @return [Action::Base] a new action instance
+      def action_for(command_name)
+        self.class.action_for(command_name).new(self)
+      end
+
+      # Get the action class for a command
+      #
+      # @param command_name [Symbol] the command name
+      # @return [Class] the action class
+      def action_class_for(command_name)
+        self.class.action_for(command_name)
+      end
+
+      # Get version information
+      #
+      # @return [String, nil] version string if tool is available
+      def version
+        return @version if defined?(@version)
+
+        @version = detect_version
+      end
+
+      # Check if the tool is available
+      #
+      # @return [Boolean] true if the tool can be executed
+      def available?
+        self.class.available?
+      end
+
+      # Execute a command with options object
+      #
+      # @param command_name [Symbol] the command to execute
+      # @param options [Object] the options object
+      # @return [Response::Base] the execution response
+      def execute(command_name, options)
+        require_relative '../executor'
+        require_relative '../options_builder'
+
+        command_name = command_name.to_sym
+        # Get command from platform profile model
+        command_def = self.class.platform_profile.command(command_name.to_s)
+
+        raise ArgumentError, "Unknown command: #{command_name}" unless command_def
+
+        # Convert options to hash
+        params = if options.is_a?(Hash)
+                   options.transform_keys(&:to_sym)
+                 else
+                   Ukiryu::OptionsBuilder.to_hash(options)
+                 end
+
+        # Build arguments
+        args = build_args(command_def, params)
+
+        # Find executable using ExecutableFinder
+        executable = ExecutableFinder.find_executable(self.class.tool_definition.name.to_s, self.class.tool_definition)
+
+        # Get shell
+        shell_sym = Ukiryu::Runtime.instance.shell
+
+        # Build environment variables (including execution mode env vars)
+        env = build_execution_env(command_def, params)
+
+        # Execute
+        result = Ukiryu::Executor.execute(
+          executable,
+          args,
+          env: env,
+          timeout: self.class.tool_definition.timeout || 90,
+          shell: shell_sym
+        )
+
+        # Build response
+        build_response(command_name, result)
+      end
+
+      private
+
+      # Build command arguments from parameters
+      #
+      # This method extends the CommandBuilder implementation to handle
+      # extra_args for manual option injection.
+      #
+      # @param command_def [Models::CommandDefinition] the command definition
+      # @param params [Hash] the parameters
+      # @return [Array<String>] the command arguments
+      def build_args(command_def, params)
+        # Call CommandBuilder's build_args first
+        args = super
+
+        # Handle extra_args for manual option injection
+        # This allows users to pass options not defined in the YAML profile
+        if params[:extra_args]
+          extra = params[:extra_args]
+          shell_sym = Ukiryu::Runtime.instance.shell
+
+          if extra.is_a?(Array)
+            shell_class = Ukiryu::Shell.class_for(shell_sym)
+            shell_instance = shell_class.new
+            extra.each { |arg| args << shell_instance.escape(arg.to_s) }
+          else
+            args << extra.to_s
+          end
+        end
+
+        args
+      end
+
+      # Build execution environment including execution mode
+      #
+      # @param command_def [Models::CommandDefinition] the command definition
+      # @param params [Hash] the parameters
+      # @return [Hash] environment variables
+      def build_execution_env(command_def, params)
+        env = build_env_vars(command_def, params)
+
+        # Handle execution modes
+        execution_mode = command_def.execution_mode
+
+        case execution_mode
+        when 'headless', :headless
+          # Set headless environment variables
+          platform = Ukiryu::Runtime.instance.platform
+          case platform
+          when :macos, :linux
+            env['DISPLAY'] ||= '' # Disable X11 display
+          when :windows
+            # Windows doesn't need special handling for headless
+          end
+        end
+
+        env
+      end
+
+      # Check if command needs batch processing flag for headless mode
+      #
+      # @param command_def [Models::CommandDefinition] the command definition
+      # @return [Boolean] true if batch processing flag should be added
+      def needs_batch_process_flag?(command_def)
+        execution_mode = command_def.execution_mode
+        ['headless', :headless].include?(execution_mode)
+      end
+
+      # Build a response object
+      #
+      # @param command_name [Symbol] the command name
+      # @param result [Executor::Result] the execution result
+      # @return [Response::Base] the response object
+      def build_response(command_name, result)
+        require_relative '../response/base'
+
+        # Get the response class for this command
+        response_class = self.class.response_class_for(command_name)
+
+        # Create response instance
+        response_class.new(result)
+      end
+
+      # Detect the tool version
+      #
+      # @return [String, nil] the detected version string
+      def detect_version
+        vd = self.class.tool_definition.version_detection
+        return nil unless vd
+
+        cmd = vd.command || '--version'
+
+        executable = ExecutableFinder.find_executable(self.class.tool_definition.name.to_s, self.class.tool_definition)
+        return nil unless executable
+
+        require_relative '../executor'
+        shell_sym = Ukiryu::Runtime.instance.shell
+
+        result = Ukiryu::Executor.execute(executable, [cmd], shell: shell_sym)
+        return nil unless result.success?
+
+        # Convert pattern string to regex if needed
+        pattern = if vd.pattern.is_a?(String)
+                    Regexp.new(vd.pattern)
+                  else
+                    vd.pattern || /(\d+\.\d+)/
+                  end
+        match = result.stdout.match(pattern) || result.stderr.match(pattern)
+        match[1] if match
+      end
+    end
+  end
+end