ukiryu 0.1.1 → 0.1.3

data/lib/ukiryu/models/env_var_definition.rb

@@ -9,21 +9,29 @@ module Ukiryu
     # @example
     #   env_var = EnvVarDefinition.new(
     #     name: 'DISPLAY',
-    #     env_var: 'DISPLAY',
     #     value: '',
     #     platforms: [:linux, :macos]
     #   )
     class EnvVarDefinition < Lutaml::Model::Serializable
       attribute :name, :string
-      attribute :env_var, :string
       attribute :value, :string
+      attribute :from, :string
       attribute :platforms, :string, collection: true, default: []
+      attribute :description, :string
 
       yaml do
         map_element 'name', to: :name
-        map_element 'env_var', to: :env_var
         map_element 'value', to: :value
+        map_element 'from', to: :from
         map_element 'platforms', to: :platforms
+        map_element 'description', to: :description
+      end
+
+      # Get platforms as symbol array
+      #
+      # @return [Array<Symbol>] platforms as symbols
+      def platforms_sym
+        @platforms_sym ||= platforms&.map(&:to_sym) || []
       end
     end
   end

data/lib/ukiryu/models/flag_definition.rb

@@ -18,16 +18,24 @@ module Ukiryu
     class FlagDefinition < Lutaml::Model::Serializable
       attribute :name, :string
       attribute :cli, :string
+      attribute :cli_short, :string
       attribute :default, :boolean, default: false
       attribute :description, :string
       attribute :platforms, :string, collection: true, default: []
+      attribute :position_constraint, :string
+      attribute :position_after, :string
+      attribute :conflicts_with, :string, collection: true, default: []
 
       yaml do
         map_element 'name', to: :name
         map_element 'cli', to: :cli
+        map_element 'cli_short', to: :cli_short
         map_element 'default', to: :default
         map_element 'description', to: :description
         map_element 'platforms', to: :platforms
+        map_element 'position_constraint', to: :position_constraint
+        map_element 'position_after', to: :position_after
+        map_element 'conflicts_with', to: :conflicts_with
       end
 
       # Get the effective default value
@@ -54,6 +62,13 @@ module Ukiryu
         @name_sym ||= name.to_sym
       end
 
+      # Get position_constraint as symbol (cached)
+      #
+      # @return [Symbol, nil] the position constraint as symbol, or nil if not set
+      def position_constraint_sym
+        @position_constraint_sym ||= position_constraint&.to_sym
+      end
+
       private
 
       # Get platforms as cached symbol array

data/lib/ukiryu/models/option_definition.rb

@@ -13,14 +13,14 @@ module Ukiryu
     #     name: 'quality',
     #     cli: '-q',
     #     type: 'integer',
-    #     format: 'single_dash_space',
+    #     assignment_delimiter: 'space',
     #     description: 'JPEG quality'
     #   )
     class OptionDefinition < Lutaml::Model::Serializable
       attribute :name, :string
       attribute :cli, :string
       attribute :type, :string, default: 'string'
-      attribute :format, :string, default: 'single_dash_space'
+      attribute :assignment_delimiter, :string, default: 'auto'
       attribute :separator, :string
       attribute :default, :string
       # Array for numeric range [min, max]
@@ -36,7 +36,7 @@ module Ukiryu
         map_element 'name', to: :name
         map_element 'cli', to: :cli
         map_element 'type', to: :type
-        map_element 'format', to: :format
+        map_element 'assignment_delimiter', to: :assignment_delimiter
         map_element 'separator', to: :separator
         map_element 'default', to: :default
         map_element 'range', to: :range
@@ -63,11 +63,11 @@ module Ukiryu
         type == 'boolean'
       end
 
-      # Get format as symbol (cached for performance)
+      # Get assignment delimiter as symbol
       #
-      # @return [Symbol] the format
-      def format_sym
-        @format_sym ||= format&.to_sym || :single_dash_space
+      # @return [Symbol] the assignment delimiter
+      def assignment_delimiter_sym
+        @assignment_delimiter_sym ||= assignment_delimiter.to_sym
       end
 
       # Hash-like access for Type validation compatibility

data/lib/ukiryu/models/platform_profile.rb

@@ -2,6 +2,7 @@
 
 require 'lutaml/model'
 require_relative 'command_definition'
+require_relative 'env_var_definition'
 require_relative 'routing'
 require_relative 'exit_codes'
 
@@ -23,9 +24,10 @@ module Ukiryu
       attribute :option_style, :string, default: 'single_dash_space'
       attribute :commands, CommandDefinition, collection: true, initialize_empty: true
       attribute :inherits, :string
-      attribute :routing_data, :hash, default: {}  # Raw routing from YAML
-      attribute :version_requirement, :string  # Semantic version requirement (e.g., ">= 2.30")
-      attribute :exit_codes, ExitCodes  # Exit code definitions for this profile
+      attribute :routing_data, :hash, default: {} # Raw routing from YAML
+      attribute :version_requirement, :string # Semantic version requirement (e.g., ">= 2.30")
+      attribute :exit_codes, ExitCodes # Exit code definitions for this profile
+      attribute :env_var_sets, :hash, default: {} # Reusable env var sets (e.g., "headless")
 
       yaml do
         map_element 'name', to: :name
@@ -38,6 +40,7 @@ module Ukiryu
         map_element 'routing', to: :routing_data
         map_element 'version_requirement', to: :version_requirement
         map_element 'exit_codes', to: :exit_codes
+        map_element 'env_var_sets', to: :env_var_sets
       end
 
       # Get the routing table as a Routing model

data/lib/ukiryu/models/routing.rb

@@ -191,7 +191,7 @@ module Ukiryu
       # @return [String] routing table as formatted string
       #
       def to_s
-        return "(empty)" if @table.empty?
+        return '(empty)' if @table.empty?
 
         @table.map { |k, v| "#{k} => #{v}" }.join(', ')
       end

data/lib/ukiryu/models/tool_definition.rb

@@ -26,7 +26,7 @@ module Ukiryu
       attribute :profiles, PlatformProfile, collection: true
       attribute :version_detection, VersionDetection
       attribute :search_paths, SearchPaths
-      attribute :components, Components  # Registry of reusable definitions
+      attribute :components, Components # Register of reusable definitions
 
       yaml do
         map_element 'ukiryu_schema', to: :ukiryu_schema
@@ -129,9 +129,7 @@ module Ukiryu
       # Get the self URI
       #
       # @return [String, nil] the self URI
-      def self_uri
-        @self_uri
-      end
+      attr_reader :self_uri
 
       # Check if a specific schema version is specified
       #

data/lib/ukiryu/models/tool_metadata.rb

@@ -9,11 +9,11 @@ module Ukiryu
     # without loading the full profile definition
 
     attr_reader :name, :version, :display_name, :implements, :homepage,
-                :description, :aliases, :tool_name, :registry_path, :default_command
+                :description, :aliases, :tool_name, :register_path, :default_command
 
     def initialize(name:, version:, display_name: nil, implements: nil,
                    homepage: nil, description: nil, aliases: nil,
-                   tool_name: nil, registry_path: nil, default_command: nil)
+                   tool_name: nil, register_path: nil, default_command: nil)
       @name = name
       @version = version
       @display_name = display_name
@@ -22,7 +22,7 @@ module Ukiryu
       @description = description
       @aliases = Array(aliases || [])
       @tool_name = tool_name || name
-      @registry_path = registry_path
+      @register_path = register_path
       @default_command = default_command
     end
 
@@ -62,9 +62,9 @@ module Ukiryu
     #
     # @param hash [Hash] the YAML profile hash
     # @param tool_name [String] the tool name
-    # @param registry_path [String] the registry path
+    # @param register_path [String] the register path
     # @return [ToolMetadata] the metadata object
-    def self.from_hash(hash, tool_name:, registry_path: nil)
+    def self.from_hash(hash, tool_name:, register_path: nil)
       new(
         name: tool_name,
         version: hash['version'],
@@ -75,7 +75,7 @@ module Ukiryu
         aliases: hash['aliases'],
         default_command: hash['default_command'],
         tool_name: tool_name,
-        registry_path: registry_path
+        register_path: register_path
       )
     end
   end

data/lib/ukiryu/models/validation_result.rb

@@ -49,7 +49,7 @@ module Ukiryu
       # @return [String] status message
       def status_message
         if valid?
-          "✓ Valid"
+          '✓ Valid'
         else
           "✗ Invalid (#{errors.size} error#{errors.size == 1 ? '' : 's'})"
         end

data/lib/ukiryu/models/version_compatibility.rb

@@ -52,7 +52,10 @@ module Ukiryu
     # @param requirement [String] the version requirement (e.g., ">= 2.30")
     # @return [VersionCompatibility] the compatibility result
     def self.check(installed_version, requirement)
-      return new(installed_version: installed_version, required_version: requirement, compatible: true, reason: nil) if !requirement || requirement.empty?
+      if !requirement || requirement.empty?
+        return new(installed_version: installed_version, required_version: requirement, compatible: true,
+                   reason: nil)
+      end
 
       parser = RequirementParser.new(requirement)
       compatible = parser.satisfied_by?(installed_version)
@@ -112,9 +115,9 @@ module Ukiryu
 
         case constraint[:operator]
         when '>', '>='
-          compare_versions(v, req_v) > 0 || (constraint[:operator] == '>=' && v == req_v)
+          compare_versions(v, req_v).positive? || (constraint[:operator] == '>=' && v == req_v)
         when '<', '<='
-          compare_versions(v, req_v) < 0 || (constraint[:operator] == '<=' && v == req_v)
+          compare_versions(v, req_v).negative? || (constraint[:operator] == '<=' && v == req_v)
         when '==', '='
           v == req_v
         when '!='

data/lib/ukiryu/models/version_detection.rb

@@ -6,21 +6,30 @@ module Ukiryu
   module Models
     # Version detection configuration
     #
-    # @example
+    # @example Command-based version detection (GNU tools)
     #   vd = VersionDetection.new(
     #     command: '--version',
     #     pattern: '(\d+\.\d+)',
     #     modern_threshold: '7.0'
     #   )
+    #
+    # @example Man-page based version detection (BSD/system tools)
+    #   vd = VersionDetection.new(
+    #     command: ['man', 'find'],
+    #     pattern: 'macOS ([\d.]+)',
+    #     source: 'man'
+    #   )
     class VersionDetection < Lutaml::Model::Serializable
       attribute :command, :string, collection: true, default: []
       attribute :pattern, :string
       attribute :modern_threshold, :string
+      attribute :source, :string, default: 'command' # 'command' or 'man'
 
       yaml do
         map_element 'command', to: :command
         map_element 'pattern', to: :pattern
         map_element 'modern_threshold', to: :modern_threshold
+        map_element 'source', to: :source
       end
 
       # Hash-like access for Base.detect_version compatibility

data/lib/ukiryu/{registry.rb → register.rb}

@@ -5,41 +5,43 @@ require_relative 'models/tool_metadata'
 require_relative 'models/validation_result'
 require_relative 'tool_index'
 require_relative 'schema_validator'
+require_relative 'register_auto_manager'
 
 module Ukiryu
-  # YAML profile registry loader
+  # YAML profile register loader
   #
-  # Provides access to tool definitions from YAML profiles in a registry directory.
+  # Provides access to tool definitions from YAML profiles in a register directory.
   # Supports lazy loading: metadata can be loaded without full profile parsing.
   #
   # Features:
   # - Cached version listings to avoid repeated glob operations
-  # - Automatic cache invalidation when registry path changes
-  class Registry
+  # - Automatic cache invalidation when register path changes
+  # - Automatic register cloning to ~/.ukiryu/register if not configured
+  class Register
     class << self
-      # Set the default registry path
+      # Set the default register path
       #
-      # @param path [String] the default registry path
+      # @param path [String] the default register path
 
-      # Get the default registry path
+      # Get the default register path
       #
-      # @return [String, nil] the default registry path
-      attr_accessor :default_registry_path
+      # @return [String, nil] the default register path
+      attr_accessor :default_register_path
 
       # Reset the version cache (mainly for testing)
       def reset_version_cache
         @version_cache = nil
-        @registry_cache_key = nil
+        @register_cache_key = nil
       end
 
       # Get all available tool names
       #
       # @return [Array<String>] list of tool names
       def tools
-        registry_path = @default_registry_path
-        return [] unless registry_path
+        register_path = effective_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)
 
         # List all directories in tools/
@@ -53,20 +55,20 @@ module Ukiryu
       # Get available versions for a tool (cached)
       #
       # @param name [String, Symbol] the tool name
-      # @param registry_path [String, nil] the registry path
+      # @param register_path [String, nil] the register path
       # @return [Hash] mapping of version filename to Gem::Version
-      def list_versions(name, registry_path: nil)
-        registry_path ||= @default_registry_path
-        return {} unless registry_path
+      def list_versions(name, register_path: nil)
+        register_path ||= effective_register_path
+        return {} unless register_path
 
         # Initialize cache
         @version_cache ||= {}
-        @registry_cache_key ||= registry_path
+        @register_cache_key ||= register_path
 
-        # Clear cache if registry path changed
-        if @registry_cache_key != registry_path
+        # Clear cache if register path changed
+        if @register_cache_key != register_path
           @version_cache.clear
-          @registry_cache_key = registry_path
+          @register_cache_key = register_path
         end
 
         # Check cache
@@ -74,7 +76,7 @@ module Ukiryu
         return @version_cache[cache_key].dup if @version_cache[cache_key]
 
         # Build version list
-        versions = scan_tool_versions(name, registry_path)
+        versions = scan_tool_versions(name, register_path)
         @version_cache[cache_key] = versions
 
         versions.dup
@@ -88,16 +90,16 @@ module Ukiryu
       # @param name [String, Symbol] the tool name or interface name
       # @param options [Hash] loading options
       # @option options [String] :version specific version to load
-      # @option options [String] :registry_path path to registry
+      # @option options [String] :register_path path to register
       # @return [ToolMetadata, nil] the tool metadata or nil if not found
       def load_tool_metadata(name, options = {})
-        registry_path = options[:registry_path] || @default_registry_path
+        register_path = options[:register_path] || effective_register_path
 
         # First try exact name match
-        yaml_content = load_tool_yaml(name, options.merge(registry_path: registry_path))
+        yaml_content = load_tool_yaml(name, options.merge(register_path: register_path))
         if yaml_content
           hash = YAML.safe_load(yaml_content, permitted_classes: [Symbol])
-          return ToolMetadata.from_hash(hash, tool_name: name.to_s, registry_path: registry_path) if hash
+          return ToolMetadata.from_hash(hash, tool_name: name.to_s, register_path: register_path) if hash
         end
 
         # If not found, try interface-based discovery using ToolIndex
@@ -110,12 +112,12 @@ module Ukiryu
       # @param name [String, Symbol] the tool name
       # @param options [Hash] loading options
       # @option options [String] :version specific version to load
-      # @option options [String] :registry_path path to registry
+      # @option options [String] :register_path path to register
       # @return [String, nil] the YAML content or nil if not found
       def load_tool_yaml(name, options = {})
-        registry_path = options[:registry_path] || @default_registry_path
+        register_path = options[:register_path] || effective_register_path
 
-        return nil unless registry_path
+        return nil unless register_path
 
         # Convert to string for path operations
         name_str = name.to_s
@@ -123,16 +125,16 @@ module Ukiryu
         # Try version-specific directory first
         version = options[:version]
         if version
-          file = File.join(registry_path, 'tools', name_str, "#{version}.yaml")
+          file = File.join(register_path, 'tools', name_str, "#{version}.yaml")
           return File.read(file) if File.exist?(file)
         end
 
         # Use cached version list if available
-        versions = list_versions(name_str, registry_path: registry_path)
+        versions = list_versions(name_str, register_path: register_path)
 
         if versions.empty?
           # Try the old format (single file per tool)
-          file = File.join(registry_path, 'tools', "#{name_str}.yaml")
+          file = File.join(register_path, 'tools', "#{name_str}.yaml")
           return File.read(file) if File.exist?(file)
 
           return nil
@@ -153,7 +155,7 @@ module Ukiryu
       # @param name [String, Symbol] the tool name
       # @param options [Hash] validation options
       # @option options [String] :version specific version to validate
-      # @option options [String] :registry_path path to registry
+      # @option options [String] :register_path path to register
       # @option options [String] :schema_path path to schema file
       # @return [ValidationResult] the validation result
       def validate_tool(name, options = {})
@@ -171,10 +173,10 @@ module Ukiryu
         end
       end
 
-      # Validate all tool profiles in the registry
+      # Validate all tool profiles in the register
       #
       # @param options [Hash] validation options
-      # @option options [String] :registry_path path to registry
+      # @option options [String] :register_path path to register
       # @option options [String] :schema_path path to schema file
       # @return [Array<ValidationResult>] list of validation results
       def validate_all_tools(options = {})
@@ -185,13 +187,27 @@ module Ukiryu
 
       private
 
+      # Get the effective register path
+      #
+      # Returns the manually set path if available, otherwise uses
+      # RegisterAutoManager to get or create the default path.
+      #
+      # @return [String, nil] the register path, or nil if unavailable
+      def effective_register_path
+        # If manually set, use that
+        return @default_register_path if @default_register_path
+
+        # Otherwise, use RegisterAutoManager (auto-clone if needed)
+        RegisterAutoManager.register_path
+      end
+
       # Scan tool versions and sort by Gem::Version
       #
       # @param name [String] the tool name
-      # @param registry_path [String] the registry path
+      # @param register_path [String] the register path
       # @return [Hash] mapping of version filename to Gem::Version
-      def scan_tool_versions(name, registry_path)
-        pattern = File.join(registry_path, 'tools', name.to_s, '*.yaml')
+      def scan_tool_versions(name, register_path)
+        pattern = File.join(register_path, 'tools', name.to_s, '*.yaml')
         files = Dir.glob(pattern)
 
         # Sort files by Gem::Version for proper version ordering