ukiryu 0.1.1 → 0.1.3

data/lib/ukiryu/definition/definition_validator.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+require_relative 'validation_result'
+require_relative 'loader'
+require 'yaml'
+require 'open-uri'
+require 'net/http'
+
+module Ukiryu
+  module Definition
+    # Validate tool definitions against JSON Schema
+    #
+    # This class provides validation functionality for tool definitions
+    # using JSON Schema. The json-schema gem is optional; if not available,
+    # basic structural validation is performed instead.
+    class DefinitionValidator
+      # Default schema version
+      DEFAULT_SCHEMA_VERSION = '1.0'
+
+      # Remote schema URL
+      REMOTE_SCHEMA_URL = 'https://raw.githubusercontent.com/ukiryu/schemas/refs/heads/main/v1/tool.schema.yaml'
+
+      class << self
+        # Check if JSON Schema validation is available
+        #
+        # @return [Boolean] true if json-schema gem is available
+        def schema_validation_available?
+          return @schema_validation_available if defined?(@schema_validation_available)
+
+          @schema_validation_available = begin
+            require 'json-schema'
+            true
+          rescue LoadError
+            false
+          end
+        end
+
+        # Find schema file
+        #
+        # @param version [String] schema version
+        # @return [String, nil] path to schema file from UKIRYU_SCHEMA_PATH env var, or nil
+        def find_schema(_version = DEFAULT_SCHEMA_VERSION)
+          # Only check environment variable for local schema path
+          schema_path = ENV['UKIRYU_SCHEMA_PATH']
+          return schema_path if schema_path && File.exist?(schema_path)
+
+          nil
+        end
+
+        # Load schema
+        #
+        # @param schema_path [String] path to schema file
+        # @return [Hash, nil] parsed schema, or nil if not available
+        def load_schema(schema_path)
+          return nil unless schema_path && File.exist?(schema_path)
+
+          case File.extname(schema_path)
+          when '.json'
+            JSON.parse(File.read(schema_path))
+          when '.yaml', '.yml'
+            YAML.safe_load(File.read(schema_path), permitted_classes: [Symbol])
+          end
+        rescue JSON::ParserError, Psych::SyntaxError, Errno::ENOENT
+          nil
+        end
+
+        # Validate a definition hash
+        #
+        # @param definition [Hash] the definition to validate
+        # @param schema_path [String, nil] optional schema path
+        # @return [ValidationResult] validation result
+        def validate(definition, schema_path: nil)
+          errors = []
+          warnings = []
+
+          # Debug: Check which tool is being validated
+          if ENV['DEBUG_SCHEMA_VALIDATION']
+            tool_name = definition['name'] || definition[:name] || 'unknown'
+            puts "DEBUG: Validating tool: #{tool_name}"
+          end
+
+          # Basic structural validation (always available)
+          structural_result = validate_structure(definition)
+          errors.concat(structural_result[:errors])
+          warnings.concat(structural_result[:warnings])
+
+          # JSON Schema validation (if available)
+          if schema_validation_available?
+            schema = schema_path ? load_schema(schema_path) : find_and_load_schema
+            if schema
+              if ENV['DEBUG_SCHEMA_VALIDATION']
+                puts "DEBUG: Schema loaded, proceeding with JSON Schema validation"
+              end
+              schema_result = validate_against_schema(definition, schema)
+              errors.concat(schema_result[:errors])
+              warnings.concat(schema_result[:warnings])
+            end
+            # If schema file not found, silently skip JSON schema validation
+            # Structural validation is sufficient
+          else
+            warnings << 'json-schema gem not available, only structural validation performed'
+          end
+
+          if errors.empty?
+            warnings.empty? ? ValidationResult.success : ValidationResult.with_warnings(warnings)
+          else
+            ValidationResult.failure(errors, warnings)
+          end
+        end
+
+        # Validate a definition file
+        #
+        # @param file_path [String] path to definition file
+        # @param schema_path [String, nil] optional schema path
+        # @return [ValidationResult] validation result
+        def validate_file(file_path, schema_path: nil)
+          # Load raw YAML hash for validation
+          definition = YAML.safe_load(File.read(file_path), permitted_classes: [Symbol, Date, Time])
+          validate(definition, schema_path: schema_path)
+        rescue Ukiryu::DefinitionNotFoundError
+          ValidationResult.failure(["File not found: #{file_path}"])
+        rescue Ukiryu::DefinitionLoadError, Ukiryu::DefinitionValidationError => e
+          ValidationResult.failure([e.message])
+        rescue Errno::ENOENT
+          ValidationResult.failure(["File not found: #{file_path}"])
+        rescue Psych::SyntaxError => e
+          ValidationResult.failure(["Invalid YAML: #{e.message}"])
+        end
+
+        # Validate a YAML string
+        #
+        # @param yaml_string [String] YAML content
+        # @param schema_path [String, nil] optional schema path
+        # @return [ValidationResult] validation result
+        def validate_string(yaml_string, schema_path: nil)
+          definition = YAML.safe_load(yaml_string, permitted_classes: [Symbol, Date, Time])
+          validate(definition, schema_path: schema_path)
+        rescue Psych::SyntaxError => e
+          ValidationResult.failure(["Invalid YAML: #{e.message}"])
+        end
+
+        private
+
+        # Find and load schema
+        #
+        # @return [Hash, nil] schema hash or nil
+        def find_and_load_schema
+          # Try local schema first
+          schema_path = find_schema
+          schema = load_schema(schema_path) if schema_path
+          return schema if schema
+
+          # Fallback to remote schema
+          download_and_load_schema
+        end
+
+        # Download schema from remote URL
+        #
+        # @return [Hash, nil] schema hash or nil
+        def download_and_load_schema
+          YAML.safe_load(URI.open(REMOTE_SCHEMA_URL).read, permitted_classes: [Symbol])
+        rescue OpenURI::HTTPError, SocketError, Timeout::Error, Psych::SyntaxError
+          nil
+        end
+
+        # Validate basic structure
+        #
+        # @param definition [Hash] the definition
+        # @return [Hash] errors and warnings
+        def validate_structure(definition)
+          errors = []
+          warnings = []
+
+          # Check if definition is a hash
+          return { errors: ['Definition must be a hash/object'], warnings: [] } unless definition.is_a?(Hash)
+
+          # Check name format (NOT validated by schema)
+          name = definition[:name] || definition['name']
+          if name
+            name_str = name.to_s
+            errors << 'Tool name must not contain whitespace' if name_str =~ /\s/
+            warnings << 'Tool name starting with number may cause issues' if name_str =~ /^[0-9]/
+            warnings << 'Tool name should contain only lowercase letters, numbers, hyphens, and underscores' if name_str !~ /^[a-z0-9_-]+$/
+          end
+
+          # Check schema version format (NOT validated by schema)
+          has_schema_version = definition.key?(:ukiryu_schema) || definition.key?('ukiryu_schema')
+          if has_schema_version
+            schema_version = definition[:ukiryu_schema] || definition['ukiryu_schema']
+            schema_version_str = schema_version.to_s
+            warnings << "Invalid schema version format: #{schema_version} (expected format: '1.0')" unless schema_version_str =~ /^\d+\.\d+$/
+          end
+
+          { errors: errors, warnings: warnings }
+        end
+
+        # Validate a profile
+        #
+        # @param profile [Hash] the profile
+        # @param index [Integer] profile index
+        # @return [Hash] errors and warnings
+        def validate_profile(profile, index)
+          errors = []
+          warnings = []
+
+          return { errors: ["Profile #{index} must be a hash/object"], warnings: [] } unless profile.is_a?(Hash)
+
+          # All profile structural validation is already done by JSON Schema
+          # (required fields, types, enum values, etc.)
+
+          { errors: errors, warnings: warnings }
+        end
+
+        # Validate against JSON Schema
+        #
+        # @param definition [Hash] the definition
+        # @param schema [Hash] JSON Schema
+        # @return [Hash] errors and warnings
+        def validate_against_schema(definition, schema)
+          errors = []
+          warnings = []
+
+          begin
+            # Debug: Check data BEFORE stringify_keys
+            if ENV['DEBUG_SCHEMA_VALIDATION']
+              tool_name = definition['name'] || definition[:name] || 'unknown'
+              puts "DEBUG: validate_against_schema for tool: #{tool_name}"
+
+              # Check flags[0] before stringify
+              if definition['profiles'] && definition['profiles'][0] &&
+                 definition['profiles'][0]['commands'] &&
+                 definition['profiles'][0]['commands'][0] &&
+                 definition['profiles'][0]['commands'][0]['flags'] &&
+                 definition['profiles'][0]['commands'][0]['flags'][0]
+                flg0_before = definition['profiles'][0]['commands'][0]['flags'][0]
+                puts "DEBUG: Flag 0 BEFORE stringify: #{flg0_before.inspect}"
+                puts "DEBUG: Flag 0 name BEFORE stringify: #{flg0_before['name'].inspect}"
+                puts "DEBUG: Flag 0 name class BEFORE stringify: #{flg0_before['name'].class}"
+              end
+            end
+
+            # Convert symbol keys to strings for JSON Schema validation
+            stringified = stringify_keys(definition)
+            # Debug: Check if keys are strings after stringify_keys
+            if ENV['DEBUG_SCHEMA_VALIDATION']
+              puts "DEBUG: After stringify_keys, checking keys..."
+              puts "DEBUG: Top-level keys: #{stringified.keys.inspect}"
+              puts "DEBUG: Top-level key classes: #{stringified.keys.map(&:class).inspect}"
+
+              # Check options[0] and flags[0] if they exist
+              if stringified['profiles'] && stringified['profiles'][0] &&
+                 stringified['profiles'][0]['commands'] &&
+                 stringified['profiles'][0]['commands'][0]
+                cmd = stringified['profiles'][0]['commands'][0]
+
+                # Check options[0]
+                if cmd['options'] && cmd['options'][0]
+                  opt0 = cmd['options'][0]
+                  puts "DEBUG: Option 0 after stringify: #{opt0.inspect}"
+                  puts "DEBUG: Option 0 keys: #{opt0.keys.inspect}"
+                  puts "DEBUG: Option 0 name: #{opt0['name'].inspect}"
+                  puts "DEBUG: Option 0 name class: #{opt0['name'].class}"
+                end
+
+                # Check flags[0]
+                if cmd['flags'] && cmd['flags'][0]
+                  flg0 = cmd['flags'][0]
+                  puts "DEBUG: Flag 0 after stringify: #{flg0.inspect}"
+                  puts "DEBUG: Flag 0 keys: #{flg0.keys.inspect}"
+                  puts "DEBUG: Flag 0 name: #{flg0['name'].inspect}"
+                  puts "DEBUG: Flag 0 name class: #{flg0['name'].class}"
+                end
+
+                # Also check options[26] for grep
+                if cmd['options'] && cmd['options'][26]
+                  opt26 = cmd['options'][26]
+                  puts "DEBUG: Option 26 after stringify: #{opt26.inspect}"
+                  puts "DEBUG: Option 26 name: #{opt26['name'].inspect}"
+                end
+              end
+              puts "DEBUG: JSON::Schema version: #{JSON::Schema::VERSION rescue 'unknown'}"
+            end
+            validation = JSON::Validator.fully_validate(schema, stringified, errors_as_objects: true)
+
+            validation.each do |error|
+              if error[:type] == 'unknown'
+                warnings << error[:message]
+              else
+                errors << "#{error[:message]} (at #{error[:fragment]})"
+              end
+            end
+          rescue JSON::Schema::ValidationError => e
+            errors << "Schema validation error: #{e.message}"
+          end
+
+          { errors: errors, warnings: warnings }
+        end
+
+        # Convert symbol keys to strings
+        #
+        # @param hash [Hash] the hash
+        # @return [Hash] hash with string keys
+        def stringify_keys(hash)
+          return hash unless hash.is_a?(Hash)
+
+          hash.transform_keys(&:to_s).transform_values do |v|
+            case v
+            when Hash
+              stringify_keys(v)
+            when Array
+              v.map { |item| item.is_a?(Hash) ? stringify_keys(item) : item }
+            else
+              v
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ukiryu/definition/discovery.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require_relative 'metadata'
+require_relative 'loader'
+
+module Ukiryu
+  module Definition
+    # Discover tool definitions in standard filesystem locations
+    #
+    # This class searches for tool definitions in XDG-compliant paths
+    # and tool-bundled locations.
+    class Discovery
+      # User data directory (XDG_DATA_HOME or ~/.local/share)
+      #
+      # @return [String] user data directory
+      def self.xdg_data_home
+        ENV.fetch('XDG_DATA_HOME', File.expand_path('~/.local/share'))
+      end
+
+      # System data directories (XDG_DATA_DIRS or /usr/local/share:/usr/share)
+      #
+      # @return [Array<String>] system data directories
+      def self.xdg_data_dirs
+        if ENV.key?('XDG_DATA_DIRS')
+          ENV.fetch('XDG_DATA_DIRS', '').split(':').map(&:strip).reject(&:empty?)
+        else
+          ['/usr/local/share', '/usr/share']
+        end
+      end
+
+      # Get the user definitions directory
+      #
+      # @return [String] path to user definitions directory
+      def self.user_definitions_directory
+        File.join(xdg_data_home, 'ukiryu', 'definitions')
+      end
+
+      # Get all search paths for definitions
+      #
+      # Returns paths in priority order (highest priority first):
+      # 1. User definitions
+      # 2. Tool-bundled paths (dynamically discovered)
+      # 3. Local system definitions
+      # 4. System definitions
+      #
+      # @return [Array<String>] search paths
+      def self.search_paths
+        paths = []
+
+        # 1. User definitions (highest priority after explicit flag)
+        paths << user_definitions_directory
+
+        # 2. Tool-bundled paths (dynamically discovered)
+        paths.concat(tool_bundled_paths)
+
+        # 3. Local system definitions
+        xdg_data_dirs.each do |dir|
+          paths << File.join(dir, 'ukiryu', 'definitions')
+        end
+
+        # 4. System definitions
+        paths << File.join(xdg_data_home, 'ukiryu', 'definitions')
+
+        paths.uniq
+      end
+
+      # Get tool-bundled definition paths
+      #
+      # Searches for tool installations and checks for bundled definitions
+      #
+      # @return [Array<String>] tool-bundled paths
+      def self.tool_bundled_paths
+        paths = []
+
+        # Check PATH for tool installations
+        ENV.fetch('PATH', '').split(':').each do |bin_dir|
+          next unless File.directory?(bin_dir)
+
+          # Check for ukiryu subdirectory alongside bin
+          parent_dir = File.dirname(bin_dir)
+          ukiryu_dir = File.join(parent_dir, 'ukiryu')
+          paths << ukiryu_dir if File.directory?(ukiryu_dir)
+
+          # Check for share/ukiryu subdirectory
+          share_dir = File.join(parent_dir, 'share', 'ukiryu')
+          paths << share_dir if File.directory?(share_dir)
+        end
+
+        # Check /opt directory structure
+        opt_paths = Dir.glob('/opt/*/ukiryu').select { |d| File.directory?(d) }
+        paths.concat(opt_paths)
+
+        paths.uniq
+      end
+
+      # Discover all available definitions
+      #
+      # Searches all paths for tool definitions and returns metadata
+      #
+      # @return [Hash<String, Array<DefinitionMetadata>>] hash of tool names to metadata
+      def self.discover
+        definitions = Hash.new { |h, k| h[k] = [] }
+
+        search_paths.each do |search_path|
+          next unless File.directory?(search_path)
+
+          discover_in_path(search_path).each do |metadata|
+            definitions[metadata.name] << metadata
+          end
+        end
+
+        # Sort each tool's definitions by priority
+        definitions.each_value(&:sort!)
+
+        definitions
+      end
+
+      # Find the best definition for a tool
+      #
+      # @param tool_name [String] the tool name
+      # @param version [String, nil] optional version constraint
+      # @return [DefinitionMetadata, nil] the best matching definition, or nil
+      def self.find(tool_name, version = nil)
+        definitions = discover[tool_name]
+        return nil if definitions.nil? || definitions.empty?
+
+        if version
+          # Find exact version match
+          definitions.find { |d| d.version == version }
+        else
+          # Return highest priority definition
+          definitions.first
+        end
+      end
+
+      # List all discovered tool names
+      #
+      # @return [Array<String>] tool names
+      def self.available_tools
+        discover.keys.sort
+      end
+
+      # Get all definitions for a specific tool
+      #
+      # @param tool_name [String] the tool name
+      # @return [Array<DefinitionMetadata>] array of definitions
+      def self.definitions_for(tool_name)
+        discover[tool_name] || []
+      end
+
+      # Discover definitions in a specific path
+      #
+      # @param search_path [String] the path to search
+      # @return [Array<DefinitionMetadata>] array of discovered metadata
+      def self.discover_in_path(search_path)
+        definitions = []
+
+        # Determine source type based on path
+        source_type = determine_source_type(search_path)
+
+        # Look for tool subdirectories (structure: {tool}/{version}.yaml)
+        if File.directory?(search_path)
+          Dir.foreach(search_path) do |tool_name|
+            next if tool_name.start_with?('.')
+
+            tool_dir = File.join(search_path, tool_name)
+            next unless File.directory?(tool_dir)
+
+            # Find YAML files in tool directory
+            Dir.glob(File.join(tool_dir, '*.yaml')).each do |yaml_file|
+              metadata = metadata_from_file(yaml_file, source_type)
+              definitions << metadata if metadata
+            rescue StandardError => e
+              # Skip invalid files silently
+              warn "[Ukiryu] Skipping invalid definition #{yaml_file}: #{e.message}"
+            end
+          end
+        end
+
+        # Also check for flat YAML files (structure: {tool}-{version}.yaml or {version}.yaml)
+        Dir.glob(File.join(search_path, '*-*.yaml')).each do |yaml_file|
+          metadata = metadata_from_file(yaml_file, source_type)
+          definitions << metadata if metadata
+        rescue StandardError => e
+          # Skip invalid files silently
+          warn "[Ukiryu] Skipping invalid definition #{yaml_file}: #{e.message}"
+        end
+
+        definitions
+      end
+
+      # Determine the source type for a search path
+      #
+      # @param path [String] the search path
+      # @return [Symbol] source type
+      def self.determine_source_type(path)
+        expanded = File.expand_path(path)
+
+        if expanded.include?(xdg_data_home)
+          :user
+        elsif expanded.include?('/opt/')
+          :bundled
+        elsif expanded.include?('/usr/local/share')
+          :local_system
+        elsif expanded.include?('/usr/share')
+          :system
+        else
+          :bundled # Default to bundled for unknown paths
+        end
+      end
+
+      # Create metadata from a YAML file
+      #
+      # @param yaml_file [String] path to the YAML file
+      # @param source_type [Symbol] source type
+      # @return [DefinitionMetadata, nil] metadata or nil if invalid
+      def self.metadata_from_file(yaml_file, source_type)
+        # Try to load just the name and version from YAML
+        yaml_content = File.read(yaml_file)
+        data = YAML.safe_load(yaml_content, permitted_classes: [Symbol])
+
+        return nil unless data.is_a?(Hash)
+        return nil unless data['name']
+
+        name = data['name']
+        version = data['version'] || '1.0' # Default version
+
+        DefinitionMetadata.new(
+          name: name,
+          version: version,
+          path: yaml_file,
+          source_type: source_type
+        )
+      rescue Psych::SyntaxError, StandardError
+        nil
+      end
+    end
+  end
+end