ukiryu 0.1.0 → 0.1.1

data/lib/ukiryu/registry.rb

@@ -1,115 +1,35 @@
 # frozen_string_literal: true
 
-require "yaml"
-require "find"
+require 'yaml'
+require_relative 'models/tool_metadata'
+require_relative 'models/validation_result'
+require_relative 'tool_index'
+require_relative 'schema_validator'
 
 module Ukiryu
   # YAML profile registry loader
   #
-  # Loads tool definitions from YAML profiles in a registry directory.
+  # Provides access to tool definitions from YAML profiles in a registry 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
     class << self
-      # Load all tool profiles from a registry directory
-      #
-      # @param path [String] the registry directory path
-      # @param options [Hash] loading options
-      # @option options [Boolean] :recursive search recursively (default: true)
-      # @option options [Boolean] :validate validate against schema (default: false)
-      # @return [Hash] loaded tools keyed by name
-      def load_from(path, options = {})
-        raise ProfileLoadError, "Registry path not found: #{path}" unless Dir.exist?(path)
-
-        tools = {}
-        recursive = options.fetch(:recursive, true)
-
-        pattern = recursive ? "**/*.yaml" : "*.yaml"
-        files = Dir.glob(File.join(path, "tools", pattern))
-
-        files.each do |file|
-          begin
-            profile = load_profile(file)
-            name = profile[:name]
-            tools[name] ||= []
-            tools[name] << profile
-          rescue => e
-            warn "Warning: Failed to load profile #{file}: #{e.message}"
-          end
-        end
-
-        tools
-      end
-
-      # Load a single profile file
-      #
-      # @param file [String] the path to the YAML file
-      # @return [Hash] the loaded profile
-      def load_profile(file)
-        content = File.read(file)
-        profile = YAML.safe_load(content, permitted_classes: [], permitted_symbols: [], aliases: true)
-
-        # Convert string keys to symbols for consistency
-        profile = symbolize_keys(profile)
-
-        # Resolve inheritance if present
-        resolve_inheritance(profile, file)
-
-        profile
-      end
-
-      # Load a specific tool by name
-      #
-      # @param name [String] the tool name
-      # @param options [Hash] loading options
-      # @option options [String] :version specific version to load
-      # @option options [String] :registry_path path to registry
-      # @return [Hash, nil] the tool profile or nil if not found
-      def load_tool(name, options = {})
-        registry_path = options[:registry_path] || @default_registry_path
-
-        raise ProfileLoadError, "Registry path not configured" unless registry_path
-
-        # Try version-specific directory first
-        version = options[:version]
-        if version
-          file = File.join(registry_path, "tools", name, "#{version}.yaml")
-          return load_profile(file) if File.exist?(file)
-        end
-
-        # Search in all matching files
-        pattern = File.join(registry_path, "tools", name, "*.yaml")
-        files = Dir.glob(pattern).sort
-
-        if files.empty?
-          # Try the old format (single file per tool)
-          file = File.join(registry_path, "tools", "#{name}.yaml")
-          return load_profile(file) if File.exist?(file)
-          return nil
-        end
-
-        # Return the latest version if version not specified
-        if version.nil?
-          # Sort by version and return the newest
-          sorted_files = files.sort_by { |f| Gem::Version.new(File.basename(f, ".yaml")) }
-          load_profile(sorted_files.last)
-        else
-          # Find specific version
-          version_file = files.find { |f| File.basename(f, ".yaml") == version }
-          version_file ? load_profile(version_file) : nil
-        end
-      end
-
       # Set the default registry path
       #
       # @param path [String] the default registry path
-      def default_registry_path=(path)
-        @default_registry_path = path
-      end
 
       # Get the default registry path
       #
       # @return [String, nil] the default registry path
-      def default_registry_path
-        @default_registry_path
+      attr_accessor :default_registry_path
+
+      # Reset the version cache (mainly for testing)
+      def reset_version_cache
+        @version_cache = nil
+        @registry_cache_key = nil
       end
 
       # Get all available tool names
@@ -119,128 +39,168 @@ module Ukiryu
         registry_path = @default_registry_path
         return [] unless registry_path
 
-        tools_dir = File.join(registry_path, "tools")
+        tools_dir = File.join(registry_path, 'tools')
         return [] unless Dir.exist?(tools_dir)
 
         # List all directories in tools/
-        Dir.glob(File.join(tools_dir, "*")).select do |path|
+        Dir.glob(File.join(tools_dir, '*')).select do |path|
           File.directory?(path)
         end.map do |path|
           File.basename(path)
         end.sort
       end
 
-      # Find the newest compatible version of a tool
+      # Get available versions for a tool (cached)
       #
-      # @param tool_name [String] the tool name
-      # @param options [Hash] search options
-      # @option options [String] :platform platform (default: auto-detect)
-      # @option options [String] :shell shell (default: auto-detect)
-      # @option options [String] :version_constraint version constraint
-      # @return [Hash, nil] the best matching profile or nil
-      def find_compatible_profile(tool_name, options = {})
-        profiles = load_tool_profiles(tool_name)
-        return nil if profiles.nil? || profiles.empty?
-
-        platform = options[:platform] || Platform.detect
-        shell = options[:shell] || Shell.detect
-        version = options[:version]
+      # @param name [String, Symbol] the tool name
+      # @param registry_path [String, nil] the registry 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
+
+        # Initialize cache
+        @version_cache ||= {}
+        @registry_cache_key ||= registry_path
+
+        # Clear cache if registry path changed
+        if @registry_cache_key != registry_path
+          @version_cache.clear
+          @registry_cache_key = registry_path
+        end
 
-        # Filter by platform and shell
-        candidates = profiles.select do |profile|
-          profile_platforms = profile[:platforms] || profile[:platform]
-          profile_shells = profile[:shells] || profile[:shell]
+        # Check cache
+        cache_key = name.to_sym
+        return @version_cache[cache_key].dup if @version_cache[cache_key]
 
-          platform_match = profile_platforms.include?(platform) if profile_platforms
-          shell_match = profile_shells.include?(shell) if profile_shells
+        # Build version list
+        versions = scan_tool_versions(name, registry_path)
+        @version_cache[cache_key] = versions
 
-          (platform_match || profile_platforms.nil?) && (shell_match || profile_shells.nil?)
-        end
+        versions.dup
+      end
 
-        # Further filter by version if specified
-        if version && !candidates.empty?
-          constraint = Gem::Requirement.new(version)
-          candidates.select! do |profile|
-            profile_version = profile[:version]
-            next true unless profile_version
+      # Load tool metadata only (lightweight, without full parsing)
+      # This is much faster than loading the full definition when only metadata is needed
+      #
+      # Supports both exact name lookup and interface-based discovery
+      #
+      # @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
+      # @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
 
-            constraint.satisfied_by?(Gem::Version.new(profile_version))
-          end
+        # First try exact name match
+        yaml_content = load_tool_yaml(name, options.merge(registry_path: registry_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
         end
 
-        # Return the first matching profile (prefer newer versions)
-        candidates.first
+        # If not found, try interface-based discovery using ToolIndex
+        index = ToolIndex.instance
+        index.find_by_interface(name.to_sym)
       end
 
-      private
+      # Load tool YAML file content (for lutaml-model parsing)
+      #
+      # @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
+      # @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
 
-      # Load all profiles for a specific tool
-      def load_tool_profiles(name)
-        registry_path = @default_registry_path
         return nil unless registry_path
 
-        pattern = File.join(registry_path, "tools", name, "*.yaml")
-        files = Dir.glob(pattern)
+        # Convert to string for path operations
+        name_str = name.to_s
 
-        return nil if files.empty?
-
-        files.flat_map do |file|
-          begin
-            profile = load_profile(file)
-            profile[:_file_path] = file
-            profile
-          rescue => e
-            warn "Warning: Failed to load profile #{file}: #{e.message}"
-            []
-          end
+        # Try version-specific directory first
+        version = options[:version]
+        if version
+          file = File.join(registry_path, 'tools', name_str, "#{version}.yaml")
+          return File.read(file) if File.exist?(file)
         end
-      end
 
-      # Resolve profile inheritance
-      #
-      # @param profile [Hash] the profile to resolve
-      # @param file_path [String] the path to the profile file
-      def resolve_inheritance(profile, file_path)
-        return unless profile[:profiles]
+        # Use cached version list if available
+        versions = list_versions(name_str, registry_path: registry_path)
 
-        base_dir = File.dirname(file_path)
+        if versions.empty?
+          # Try the old format (single file per tool)
+          file = File.join(registry_path, 'tools', "#{name_str}.yaml")
+          return File.read(file) if File.exist?(file)
 
-        profile[:profiles].each do |p|
-          next unless p[:inherits]
+          return nil
+        end
 
-          parent_profile = find_parent_profile(p[:inherits], profile[:profiles], base_dir)
-          if parent_profile
-            # Merge parent into child (child takes precedence)
-            p.merge!(parent_profile) { |_, child_val, _| child_val }
-          end
+        # Return specific version if requested
+        if version
+          version_file = versions.keys.find { |f| File.basename(f, '.yaml') == version }
+          return version_file ? File.read(version_file) : nil
         end
+
+        # Return the latest version (already sorted from scan_tool_versions)
+        File.read(versions.keys.last)
       end
 
-      # Find a parent profile within the same file
-      def find_parent_profile(name, profiles, _base_dir)
-        profiles.find { |p| p[:name] == name }
+      # Validate a tool profile against the schema
+      #
+      # @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] :schema_path path to schema file
+      # @return [ValidationResult] the validation result
+      def validate_tool(name, options = {})
+        yaml_content = load_tool_yaml(name, options)
+        return Models::ValidationResult.not_found(name.to_s) unless yaml_content
+
+        profile = YAML.safe_load(yaml_content, permitted_classes: [Symbol])
+        return Models::ValidationResult.invalid(name.to_s, ['Failed to parse YAML']) unless profile
+
+        errors = SchemaValidator.validate_profile(profile, options)
+        if errors.empty?
+          Models::ValidationResult.valid(name.to_s)
+        else
+          Models::ValidationResult.invalid(name.to_s, errors)
+        end
       end
 
-      # Recursively convert string keys to symbols
+      # Validate all tool profiles in the registry
       #
-      # @param hash [Hash] the hash to convert
-      # @return [Hash] the hash with symbolized keys
-      def symbolize_keys(hash)
-        return hash unless hash.is_a?(Hash)
-
-        hash.transform_keys do |key|
-          key.is_a?(String) ? key.to_sym : key
-        end.transform_values do |value|
-          case value
-          when Hash
-            symbolize_keys(value)
-          when Array
-            value.map { |v| v.is_a?(Hash) ? symbolize_keys(v) : v }
-          else
-            value
-          end
+      # @param options [Hash] validation options
+      # @option options [String] :registry_path path to registry
+      # @option options [String] :schema_path path to schema file
+      # @return [Array<ValidationResult>] list of validation results
+      def validate_all_tools(options = {})
+        tools.map do |tool_name|
+          validate_tool(tool_name, options)
         end
       end
+
+      private
+
+      # Scan tool versions and sort by Gem::Version
+      #
+      # @param name [String] the tool name
+      # @param registry_path [String] the registry 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')
+        files = Dir.glob(pattern)
+
+        # Sort files by Gem::Version for proper version ordering
+        files.sort_by { |f| Gem::Version.new(File.basename(f, '.yaml')) }
+             .each_with_object({}) { |file, hash| hash[file] = Gem::Version.new(File.basename(file, '.yaml')) }
+      rescue ArgumentError
+        # If version parsing fails, return unsorted files
+        files.each_with_object({}) { |file, hash| hash[file] = File.basename(file, '.yaml') }
+      end
     end
   end
 end

data/lib/ukiryu/response/base.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module Ukiryu
+  module Response
+    # Abstract base class for all response classes
+    #
+    # This class wraps the raw Executor::Result object and provides
+    # a structured interface for accessing command execution results.
+    #
+    # @abstract
+    class Base
+      # Create a new response
+      #
+      # @param result [Executor::Result] the raw execution result
+      def initialize(result)
+        @result = result
+      end
+
+      # Check if the command was successful
+      #
+      # @return [Boolean] true if exit code was 0
+      def success?
+        @result.status.zero?
+      end
+
+      # Get the exit code
+      #
+      # @return [Integer] the exit code
+      def exit_code
+        @result.status
+      end
+
+      # Get the exit code meaning (symbol)
+      #
+      # @return [String, nil] the exit code meaning (e.g., "merge_conflict") or nil if not defined
+      def exit_code_meaning
+        tool_name = @result.command_info.tool_name
+        command_name = @result.command_info.command_name
+        return nil unless tool_name && command_name
+
+        # Look up the tool by name
+        require_relative '../tool'
+        tool = Tool.find_by(tool_name.to_sym)
+        return nil unless tool
+
+        # Get exit codes from the tool's profile
+        profile = tool.profile
+        return nil unless profile
+
+        command_profile = profile.compatible_profile
+        return nil unless command_profile
+
+        # First, try to get exit codes from the specific command
+        command = command_profile.command(command_name.to_s)
+        exit_codes = command&.exit_codes
+
+        # Fall back to profile-level exit codes if command doesn't define its own
+        exit_codes ||= command_profile.exit_codes
+        return nil unless exit_codes
+
+        exit_codes.meaning(@result.status)
+      end
+
+      # Get the standard output
+      #
+      # @return [String] the stdout content
+      def stdout
+        @result.output
+      end
+
+      # Get the standard error
+      #
+      # @return [String] the stderr content
+      def stderr
+        @result.error_output
+      end
+
+      # Get stdout as lines
+      #
+      # @return [Array<String>] the stdout split into lines
+      def stdout_lines
+        @result.stdout_lines
+      end
+
+      # Get stderr as lines
+      #
+      # @return [Array<String>] the stderr split into lines
+      def stderr_lines
+        @result.stderr_lines
+      end
+
+      # Get the command that was executed
+      #
+      # @return [String] the full command string
+      def command
+        @result.command_info.full_command
+      end
+
+      # Get the executable path
+      #
+      # @return [String] the executable that was run
+      def executable
+        @result.command_info.executable
+      end
+
+      # Get the command arguments
+      #
+      # @return [Array<String>] the arguments passed to the command
+      def arguments
+        @result.command_info.arguments
+      end
+
+      # Get the shell type used
+      #
+      # @return [Symbol] the shell type
+      def shell
+        @result.command_info.shell
+      end
+
+      # Get the execution duration
+      #
+      # @return [Float] duration in seconds
+      def duration
+        @result.metadata.duration
+      end
+
+      # Get the formatted duration string
+      #
+      # @return [String] human-readable duration (e.g., "1.2s", "450ms")
+      def formatted_duration
+        @result.metadata.formatted_duration
+      end
+
+      # Get the start time
+      #
+      # @return [Time] when the command started
+      def started_at
+        @result.metadata.started_at
+      end
+
+      # Get the end time
+      #
+      # @return [Time] when the command finished
+      def finished_at
+        @result.metadata.finished_at
+      end
+
+      # Check if the command timed out
+      #
+      # @return [Boolean] true if the command exceeded its timeout
+      def timed_out?
+        @result.timeout_exceeded?
+      end
+
+      # Get the raw result object
+      #
+      # @return [Executor::Result] the raw execution result
+      def raw_result
+        @result
+      end
+
+      # Convert to hash representation
+      #
+      # @return [Hash] hash representation of the response
+      def to_h
+        hash = {
+          success: success?,
+          exit_code: exit_code,
+          stdout: stdout,
+          stderr: stderr,
+          command: command,
+          executable: executable,
+          arguments: arguments,
+          shell: shell,
+          duration: duration,
+          started_at: started_at.iso8601,
+          finished_at: finished_at.iso8601
+        }
+
+        # Add exit code meaning if available
+        meaning = exit_code_meaning
+        hash[:exit_code_meaning] = meaning if meaning
+
+        hash
+      end
+      alias to_hash to_h
+
+      # String representation
+      #
+      # @return [String] summary of the response
+      def to_s
+        if success?
+          "Success (exit #{exit_code}#{format_meaning}, #{formatted_duration})"
+        else
+          "Failed (exit #{exit_code}#{format_meaning}, #{formatted_duration})"
+        end
+      end
+
+      # Format exit code meaning
+      #
+      # @return [String] formatted meaning (e.g., ": merge_conflict")
+      def format_meaning
+        meaning = exit_code_meaning
+        return '' unless meaning
+
+        ": #{meaning}"
+      end
+
+      # Inspect representation
+      #
+      # @return [String] detailed inspection string
+      def inspect
+        "#<#{self.class.name} success=#{success?} exit_code=#{exit_code} duration=#{formatted_duration}>"
+      end
+    end
+  end
+end