ukiryu 0.1.1 → 0.1.3

data/lib/ukiryu/tool.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'registry'
+require_relative 'register'
 require_relative 'executor'
 require_relative 'shell'
 require_relative 'runtime'
@@ -48,7 +48,7 @@ module Ukiryu
       #
       # @param name [String] the tool name
       # @param options [Hash] initialization options
-      # @option options [String] :registry_path path to tool profiles
+      # @option options [String] :register_path path to tool profiles
       # @option options [Symbol] :platform platform to use
       # @option options [Symbol] :shell shell to use
       # @option options [String] :version specific version to use
@@ -59,7 +59,7 @@ module Ukiryu
         cached = tools_cache[cache_key]
         return cached if cached
 
-        # Load profile from registry
+        # Load profile from register
         profile = load_profile(name, options)
         raise ToolNotFoundError, "Tool not found: #{name}" unless profile
 
@@ -95,8 +95,8 @@ module Ukiryu
         begin
           tool = get(identifier, options)
           if logger.debug_enabled?
-            require_relative 'registry'
-            all_tools = Registry.tools
+            require_relative 'register'
+            all_tools = Register.tools
             logger.debug_section_tool_resolution(
               identifier: identifier,
               platform: platform,
@@ -134,8 +134,8 @@ module Ukiryu
         end
 
         # 4. Fallback to exhaustive search (should rarely reach here)
-        require_relative 'registry'
-        all_tools = Registry.tools
+        require_relative 'register'
+        all_tools = Register.tools
 
         all_tools.each do |tool_name|
           tool_def = Tools::Generator.load_tool_definition(tool_name)
@@ -215,6 +215,32 @@ module Ukiryu
         Tools::Generator.clear_cache
       end
 
+      # Clear the definition cache only
+      #
+      # @api public
+      def clear_definition_cache
+        require_relative 'definition/loader'
+        Definition::Loader.clear_cache
+      end
+
+      # Alias for load - load from file path
+      #
+      # @param file_path [String] path to the YAML file
+      # @param options [Hash] initialization options
+      # @return [Tool] the tool instance
+      def from_file(file_path, options = {})
+        load(file_path, options)
+      end
+
+      # Alias for load_from_string - load from YAML string
+      #
+      # @param yaml_string [String] YAML content
+      # @param options [Hash] initialization options
+      # @return [Tool] the tool instance
+      def from_definition(yaml_string, options = {})
+        load_from_string(yaml_string, options)
+      end
+
       # Configure default options
       #
       # @param options [Hash] default options
@@ -230,15 +256,14 @@ module Ukiryu
       # @option options [Symbol] :validation validation mode (:strict, :lenient, :none)
       # @option options [Symbol] :version_check version check mode (:strict, :lenient, :probe)
       # @return [Tool] the tool instance
-      # @raise [LoadError] if file cannot be loaded or validation fails
+      # @raise [DefinitionLoadError] if file cannot be loaded or validation fails
       def load(file_path, options = {})
-        require 'yaml'
-        require_relative 'models/tool_definition'
+        require_relative 'definition/loader'
+        require_relative 'definition/sources/file'
 
-        raise LoadError, "File not found: #{file_path}" unless File.exist?(file_path)
-
-        content = File.read(file_path)
-        load_from_string(content, options.merge(file_path: file_path))
+        source = Definition::Sources::FileSource.new(file_path)
+        profile = Definition::Loader.load_from_source(source, options)
+        new(profile, options.merge(definition_source: source))
       end
 
       # Load a tool definition from a YAML string
@@ -249,25 +274,14 @@ module Ukiryu
       # @option options [Symbol] :validation validation mode (:strict, :lenient, :none)
       # @option options [Symbol] :version_check version check mode (:strict, :lenient, :probe)
       # @return [Tool] the tool instance
-      # @raise [LoadError] if YAML cannot be parsed or validation fails
+      # @raise [DefinitionLoadError] if YAML cannot be parsed or validation fails
       def load_from_string(yaml_string, options = {})
-        require_relative 'models/tool_definition'
-
-        begin
-          # Use lutaml-model's from_yaml to parse
-          profile = Models::ToolDefinition.from_yaml(yaml_string)
-        rescue Psych::SyntaxError => e
-          raise LoadError, "Invalid YAML: #{e.message}"
-        rescue StandardError => e
-          raise LoadError, "Invalid YAML: #{e.message}"
-        end
-
-        # Validate profile if validation mode is set
-        validation_mode = options[:validation] || :strict
-        validate_profile(profile, validation_mode) if validation_mode != :none
+        require_relative 'definition/loader'
+        require_relative 'definition/sources/string'
 
-        # Create tool instance
-        new(profile, options)
+        source = Definition::Sources::StringSource.new(yaml_string)
+        profile = Definition::Loader.load_from_source(source, options)
+        new(profile, options.merge(definition_source: source))
       end
 
       # Load a tool from bundled system locations
@@ -286,12 +300,10 @@ module Ukiryu
 
         search_paths.each do |base_path|
           Dir.glob(File.join(base_path, tool_name.to_s, '*.yaml')).each do |file|
-            begin
-              return load(file, options)
-            rescue LoadError, NameError
-              # Try next file
-              next
-            end
+            return load(file, options)
+          rescue DefinitionLoadError, DefinitionNotFoundError
+            # Try next file
+            next
           end
         end
 
@@ -367,47 +379,6 @@ module Ukiryu
 
       private
 
-      # Validate a tool profile
-      #
-      # @param profile [Models::ToolDefinition] the profile to validate
-      # @param mode [Symbol] validation mode (:strict, :lenient)
-      # @raise [LoadError] if validation fails in strict mode
-      def validate_profile(profile, mode)
-        errors = []
-
-        # Check required fields
-        errors << "Missing 'name' field" unless profile.name
-        errors << "Missing 'version' field" unless profile.version
-        errors << "Missing 'profiles' field or profiles is empty" unless profile.profiles&.any?
-
-        # Check ukiryu_schema format if present
-        if profile.ukiryu_schema && !profile.ukiryu_schema.match?(/^\d+\.\d+$/)
-          errors << "Invalid ukiryu_schema format: #{profile.ukiryu_schema}"
-        end
-
-        # Check $self URI format if present
-        if profile.self_uri && !valid_uri?(profile.self_uri)
-          errors << "Invalid $self URI format: #{profile.self_uri}" if mode == :strict
-        end
-
-        if errors.any?
-          message = "Profile validation failed:\n  - #{errors.join("\n  - ")}"
-          if mode == :strict
-            raise LoadError, message
-          else
-            warn "[Ukiryu] #{message}" if mode == :lenient
-          end
-        end
-      end
-
-      # Check if a string is a valid URI
-      #
-      # @param uri_string [String] the URI to check
-      # @return [Boolean] true if valid URI
-      def valid_uri?(uri_string)
-        (uri_string =~ %r{^https?://} || uri_string =~ %r{^file://}) ? true : false
-      end
-
       # Generate a cache key for a tool
       def cache_key_for(name, options)
         runtime = Runtime.instance
@@ -434,9 +405,11 @@ module Ukiryu
     #
     # @param profile [Models::ToolDefinition] the tool definition model
     # @param options [Hash] initialization options
+    # @option options [Definition::Source] :definition_source the source of this definition
     def initialize(profile, options = {})
       @profile = profile
       @options = options
+      @definition_source = options[:definition_source]
       runtime = Runtime.instance
 
       # Allow override via options for testing
@@ -471,6 +444,25 @@ module Ukiryu
       @version || detect_version
     end
 
+    # Get the definition source if loaded from non-register source
+    #
+    # @return [Definition::Source, nil] the definition source
+    attr_reader :definition_source
+
+    # Get the definition path if loaded from file
+    #
+    # @return [String, nil] the file path
+    def definition_path
+      @definition_source&.path if @definition_source.respond_to?(:path)
+    end
+
+    # Get the definition mtime if loaded from file
+    #
+    # @return [Time, nil] the file modification time
+    def definition_mtime
+      @definition_source&.mtime if @definition_source.respond_to?(:mtime)
+    end
+
     # Get the executable path
     #
     # @return [String] the executable path
@@ -528,7 +520,7 @@ module Ukiryu
       Executor.execute(
         @executable,
         args,
-        env: build_env_vars(command, params),
+        env: build_env_vars(command, @command_profile, params),
         timeout: @profile.timeout || 90,
         shell: @shell,
         stdin: stdin,
@@ -658,7 +650,7 @@ module Ukiryu
       Executor.execute(
         resolution[:executable],
         args,
-        env: build_env_vars(action, params),
+        env: build_env_vars(action, @command_profile, params),
         timeout: @profile.timeout || 90,
         shell: @shell,
         stdin: stdin,
@@ -726,15 +718,37 @@ module Ukiryu
     end
 
     # Detect tool version using VersionDetector
+    #
+    # @return [String, nil] the detected version or nil if not detected
+    public
+
     def detect_version
       vd = @profile.version_detection
       return nil unless vd
 
+      # Only attempt version detection if command is configured
+      return nil if vd.command.nil? || vd.command.empty?
+
+      # For man page detection, the executable is 'man' and command is the tool name
+      # For command detection, the executable is the tool itself
+      source = vd.respond_to?(:source) ? vd.source : 'command'
+      if source == 'man'
+        # command is ['man', 'tool_name'], so:
+        # - executable = 'man'
+        # - command = ['tool_name']  (just the tool name for man)
+        executable = 'man'
+        command_args = vd.command[1..] # Skip 'man', use rest of array
+      else
+        executable = @executable
+        command_args = vd.command
+      end
+
       VersionDetector.detect(
-        executable: @executable,
-        command: vd.command || '--version',
+        executable: executable,
+        command: command_args,
         pattern: vd.pattern || /(\d+\.\d+)/,
-        shell: @shell
+        shell: @shell,
+        source: source
       )
     end
 
@@ -749,20 +763,20 @@ module Ukiryu
       requirement = profile_version_requirement
 
       # If no requirement, always compatible
-      return VersionCompatibility.new(
-        installed_version: installed || 'unknown',
-        required_version: 'none',
-        compatible: true,
-        reason: nil
-      ) if !requirement || requirement.empty?
+      if !requirement || requirement.empty?
+        return VersionCompatibility.new(
+          installed_version: installed || 'unknown',
+          required_version: 'none',
+          compatible: true,
+          reason: nil
+        )
+      end
 
       # If installed version unknown, probe for it
-      if !installed && mode == :probe
-        installed = detect_version
-      end
+      installed = detect_version if !installed && mode == :probe
 
       # If still unknown, handle based on mode
-      if !installed
+      unless installed
         if mode == :strict
           return VersionCompatibility.new(
             installed_version: 'unknown',
@@ -818,8 +832,6 @@ module Ukiryu
       result.success? && !result.stderr.include?('unknown')
     end
 
-    private
-
     # Get version requirement from compatible profile
     #
     # @return [String, nil] the version requirement

data/lib/ukiryu/tool_index.rb

@@ -9,7 +9,7 @@ module Ukiryu
   # This class maintains cached mappings for:
   # - Interfaces to tools (multiple tools can implement one interface)
   # - Aliases to tool names
-  # - Registry change detection via mtime
+  # - Register change detection via mtime
   #
   # Built once and cached for the lifetime of the process.
   #
@@ -31,13 +31,13 @@ module Ukiryu
 
     # 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
+    # @param register_path [String] the path to the tool register
+    def initialize(register_path: Ukiryu::Register.default_register_path)
+      @register_path = register_path
       @interface_to_tools = {} # interface => [tool_names]
       @alias_to_tool = {}      # alias => tool_name
       @built = false
-      @cache_key = nil        # Registry state for change detection
+      @cache_key = nil # Register state for change detection
     end
 
     # Find tool metadata by interface name
@@ -89,7 +89,7 @@ module Ukiryu
       @interface_to_tools.dup
     end
 
-    # Check if the index needs rebuilding due to registry changes
+    # Check if the index needs rebuilding due to register changes
     #
     # @return [Boolean] true if rebuild is needed
     def stale?
@@ -99,13 +99,13 @@ module Ukiryu
       @cache_key != current_cache_key
     end
 
-    # Update the registry path
+    # Update the register path
     #
-    # @param new_path [String] the new registry path
-    def registry_path=(new_path)
-      return if @registry_path == new_path
+    # @param new_path [String] the new register path
+    def register_path=(new_path)
+      return if @register_path == new_path
 
-      @registry_path = new_path
+      @register_path = new_path
       @built = false # Rebuild index with new path
       @cache_key = nil
       @interface_to_tools = {}
@@ -119,12 +119,12 @@ module Ukiryu
       build_index if stale?
     end
 
-    # Build cache key for registry change detection
-    # Uses mtime of registry directory + file count for fast comparison
+    # Build cache key for register change detection
+    # Uses mtime of register directory + file count for fast comparison
     #
     # @return [String] the cache key
     def build_cache_key
-      current_path = registry_path
+      current_path = register_path
       return 'empty' unless current_path
 
       tools_dir = File.join(current_path, 'tools')
@@ -137,17 +137,17 @@ module Ukiryu
       "#{mtime}-#{file_count}"
     end
 
-    # Get the current registry path
+    # Get the current register path
     #
-    # @return [String, nil] the registry path
-    def registry_path
-      @registry_path ||= Ukiryu::Registry.default_registry_path
+    # @return [String, nil] the register path
+    def register_path
+      @register_path ||= Ukiryu::Register.default_register_path
     end
 
     # Build the index by scanning tool directories
     # This is done once and cached
     def build_index
-      current_path = registry_path
+      current_path = register_path
       return unless current_path
 
       tools_dir = File.join(current_path, 'tools')
@@ -175,7 +175,7 @@ module Ukiryu
 
         # Index by alias
         aliases = hash['aliases']
-        if aliases && aliases.respond_to?(:each)
+        if aliases.respond_to?(:each)
           aliases.each do |alias_name|
             @alias_to_tool[alias_name.to_sym] = tool_sym
           end
@@ -200,7 +200,7 @@ module Ukiryu
       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)
+      ToolMetadata.from_hash(hash, tool_name: tool_name.to_s, register_path: register_path)
     end
 
     # Load YAML content for a specific tool
@@ -208,7 +208,7 @@ module Ukiryu
     # @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
+      current_path = register_path
       return nil unless current_path
 
       # Search for version files

data/lib/ukiryu/tools/base.rb

@@ -251,8 +251,8 @@ module Ukiryu
         # Get shell
         shell_sym = Ukiryu::Runtime.instance.shell
 
-        # Build environment variables (including execution mode env vars)
-        env = build_execution_env(command_def, params)
+        # Build environment variables (including env var sets)
+        env = build_execution_env(command_def, @platform_profile, params)
 
         # Execute
         result = Ukiryu::Executor.execute(
@@ -299,30 +299,14 @@ module Ukiryu
         args
       end
 
-      # Build execution environment including execution mode
+      # Build execution environment
       #
       # @param command_def [Models::CommandDefinition] the command definition
+      # @param profile [Models::PlatformProfile] the profile (for env_var_sets)
       # @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
+      def build_execution_env(command_def, profile, params)
+        build_env_vars(command_def, profile, params)
       end
 
       # Check if command needs batch processing flag for headless mode
@@ -330,8 +314,8 @@ module Ukiryu
       # @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)
+        # Check if command uses the 'headless' env var set
+        command_def.use_env_vars&.include?('headless') || false
       end
 
       # Build a response object
@@ -356,7 +340,10 @@ module Ukiryu
         vd = self.class.tool_definition.version_detection
         return nil unless vd
 
-        cmd = vd.command || '--version'
+        # Only attempt version detection if command is configured
+        return nil if vd.command.nil? || vd.command.empty?
+
+        cmd = vd.command
 
         executable = ExecutableFinder.find_executable(self.class.tool_definition.name.to_s, self.class.tool_definition)
         return nil unless executable

data/lib/ukiryu/tools/generator.rb

@@ -45,15 +45,15 @@ module Ukiryu
           tool_class
         end
 
-        # Load a ToolDefinition model from the registry
+        # Load a ToolDefinition model from the register
         #
         # @param tool_name [Symbol] the tool name
         # @return [Models::ToolDefinition, nil] the tool definition model
         def load_tool_definition(tool_name)
-          require_relative '../registry'
+          require_relative '../register'
 
           # Load the YAML file content
-          yaml_content = Registry.load_tool_yaml(tool_name)
+          yaml_content = Register.load_tool_yaml(tool_name)
           return nil unless yaml_content
 
           # Use lutaml-model's from_yaml to parse
@@ -136,12 +136,12 @@ module Ukiryu
         #
         # @return [Array<Symbol>] list of tool names
         def available_tools
-          require_relative '../registry'
+          require_relative '../register'
 
-          registry_path = Registry.default_registry_path
-          return [] unless registry_path
+          register_path = Register.default_register_path
+          return [] unless register_path
 
-          tools_dir = File.join(registry_path, 'tools')
+          tools_dir = File.join(register_path, 'tools')
           return [] unless Dir.exist?(tools_dir)
 
           Dir.entries(tools_dir)

data/lib/ukiryu/tools.rb

@@ -65,10 +65,10 @@ module Ukiryu
       # @param alias_name [Symbol] the alias to resolve
       # @return [Symbol, nil] the platform-specific tool name
       def find_platform_implementation(alias_name)
-        registry_path = Registry.default_registry_path
-        return nil unless registry_path && Dir.exist?(registry_path)
+        register_path = Register.default_register_path
+        return nil unless register_path && Dir.exist?(register_path)
 
-        tools_dir = File.join(registry_path, 'tools')
+        tools_dir = File.join(register_path, 'tools')
         return nil unless Dir.exist?(tools_dir)
 
         current_platform = Platform.detect

data/lib/ukiryu/type.rb

@@ -88,7 +88,10 @@ module Ukiryu
         value = value.to_s
         raise ValidationError, 'String cannot be empty' if value.empty? && !options[:allow_empty]
 
-        raise ValidationError, "String does not match required pattern: #{options[:pattern]}" if options[:pattern] && value !~ options[:pattern]
+        if options[:pattern] && value !~ options[:pattern]
+          raise ValidationError,
+                "String does not match required pattern: #{options[:pattern]}"
+        end
 
         value
       end
@@ -146,7 +149,10 @@ module Ukiryu
         if options[:values]
           # Convert values to symbols for comparison (handle both string and symbol values)
           valid_values = options[:values].map { |v| v.is_a?(String) ? v.to_sym : v }
-          raise ValidationError, "Invalid symbol: #{value.inspect}. Valid values: #{options[:values].inspect}" unless valid_values.include?(value)
+          unless valid_values.include?(value)
+            raise ValidationError,
+                  "Invalid symbol: #{value.inspect}. Valid values: #{options[:values].inspect}"
+          end
         end
 
         value
@@ -214,9 +220,15 @@ module Ukiryu
       def validate_array(value, options)
         array = value.is_a?(Array) ? value : [value]
 
-        raise ValidationError, "Array has #{array.size} elements, minimum is #{options[:min]}" if options[:min] && array.size < options[:min]
+        if options[:min] && array.size < options[:min]
+          raise ValidationError,
+                "Array has #{array.size} elements, minimum is #{options[:min]}"
+        end
 
-        raise ValidationError, "Array has #{array.size} elements, maximum is #{options[:max]}" if options[:max] && array.size > options[:max]
+        if options[:max] && array.size > options[:max]
+          raise ValidationError,
+                "Array has #{array.size} elements, maximum is #{options[:max]}"
+        end
 
         if options[:size]
           if options[:size].is_a?(Integer)
@@ -225,7 +237,10 @@ module Ukiryu
                     "Array has #{array.size} elements, expected #{options[:size]}"
             end
           elsif options[:size].is_a?(Array)
-            raise ValidationError, "Array has #{array.size} elements, expected one of: #{options[:size].inspect}" unless options[:size].include?(array.size)
+            unless options[:size].include?(array.size)
+              raise ValidationError,
+                    "Array has #{array.size} elements, expected one of: #{options[:size].inspect}"
+            end
           end
         end
 

data/lib/ukiryu/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ukiryu
-  VERSION = '0.1.1'
+  VERSION = '0.1.3'
 end

data/lib/ukiryu/version_detector.rb

@@ -9,14 +9,23 @@ module Ukiryu
   # - Configurable version command patterns
   # - Regex pattern matching for version strings
   # - Proper shell handling for command execution
+  # - Support for man-page based version detection (BSD/system tools)
   #
-  # @example Detecting version
+  # @example Detecting version from command output (GNU tools)
   #   version = VersionDetector.detect(
   #     executable: '/usr/bin/ffmpeg',
   #     command: '-version',
   #     pattern: /version (\d+\.\d+)/,
   #     shell: :bash
   #   )
+  #
+  # @example Detecting version from man page (BSD/system tools)
+  #   version = VersionDetector.detect(
+  #     executable: '/usr/bin/man',
+  #     command: ['man', 'find'],
+  #     pattern: /macOS ([\d.]+)/,
+  #     source: 'man'
+  #   )
   module VersionDetector
     class << self
       # Detect the version of an external tool
@@ -25,8 +34,9 @@ module Ukiryu
       # @param command [String, Array<String>] the version command (default: '--version')
       # @param pattern [Regexp] the regex pattern to extract version
       # @param shell [Symbol] the shell to use for execution
+      # @param source [String] the version source: 'command' (default) or 'man'
       # @return [String, nil] the detected version or nil if not found
-      def detect(executable:, command: '--version', pattern: /(\d+\.\d+)/, shell: nil)
+      def detect(executable:, command: '--version', pattern: /(\d+\.\d+)/, shell: nil, source: 'command')
         # Return nil if executable is not found
         return nil if executable.nil? || executable.empty?
 
@@ -43,6 +53,15 @@ module Ukiryu
         stdout = result.stdout.scrub
         stderr = result.stderr.scrub
 
+        # For man pages, look at the tail (last few lines)
+        if source == 'man'
+          output = stdout + stderr
+          # Get last 500 characters to catch the OS version at bottom
+          tail = output[-500..] || output
+          match = tail.match(pattern)
+          return match[1] if match
+        end
+
         match = stdout.match(pattern) || stderr.match(pattern)
         match[1] if match
       end