ukiryu 0.1.1 → 0.1.3

data/lib/ukiryu/cli_commands/system_command.rb

@@ -28,51 +28,46 @@ module Ukiryu
         require_relative '../shell'
 
         all_shells = Shell.all_valid
-        available_shells = Shell.available_shells
         platform_shells = Shell.valid_for_platform
+        available_shells = platform_shells.select { |shell| Shell.available?(shell) }
+        not_installed_shells = platform_shells.reject { |shell| Shell.available?(shell) }
+        not_supported_shells = all_shells - platform_shells
 
-        say 'Available Shells on This System:', :cyan
+        say 'Available shells', :cyan
+        say ''
+        say '  The following shells are installed and supported on this platform:'
         say ''
 
         if available_shells.empty?
-          say '  No shells detected', :dim
+          say '    No supported shells detected', :dim
         else
           available_shells.each do |shell|
-            status = '✓'
-            say "  #{status} #{shell}", :green
+            say "    • #{shell_name_with_description(shell)}", :green
           end
         end
 
-        say ''
-        say 'All Supported Shells:', :cyan
-        say ''
-
-        all_shells.each do |shell|
-          is_available = available_shells.include?(shell)
-          is_platform = platform_shells.include?(shell)
+        if not_installed_shells.any?
+          say ''
+          say 'Additional supported shells', :cyan
+          say ''
+          say '  These shells are supported but not currently installed:'
+          say ''
 
-          status = if is_available
-                     '✓'
-                   elsif is_platform
-                     '✗'
-                   else
-                     '-'
-                   end
+          not_installed_shells.each do |shell|
+            say "    • #{shell_name_with_description(shell)}", :dim
+          end
+        end
 
-          color = if is_available
-                    :green
-                  else
-                    (is_platform ? :red : :dim)
-                  end
-          note = if !is_platform
-                   ' (not supported on this platform)'
-                 elsif !is_available
-                   ' (supported but not found)'
-                 else
-                   ''
-                 end
+        if not_supported_shells.any?
+          say ''
+          say 'Not available on this platform', :cyan
+          say ''
+          say '  These shells are not supported on this platform:'
+          say ''
 
-          say "  #{status} #{shell}#{note}", color
+          not_supported_shells.each do |shell|
+            say "    • #{shell_name_with_description(shell)}", :dim
+          end
         end
 
         say ''
@@ -85,6 +80,29 @@ module Ukiryu
 
         say "Shell override: #{config_shell} (set via --shell, UKIRYU_SHELL, or config)", :yellow
       end
+
+      # Get shell name with brief description
+      #
+      # @param shell_sym [Symbol] the shell symbol
+      # @return [String] formatted name with description
+      def shell_name_with_description(shell_sym)
+        case shell_sym
+        when :bash
+          'bash - GNU Bourne Again SHell'
+        when :zsh
+          'zsh - Z shell'
+        when :fish
+          'fish - Friendly interactive shell'
+        when :sh
+          'sh - POSIX shell'
+        when :powershell
+          'powershell - PowerShell command-line shell'
+        when :cmd
+          'cmd - Windows Command Prompt'
+        else
+          shell_sym.to_s
+        end
+      end
     end
   end
 end

data/lib/ukiryu/cli_commands/validate_command.rb

@@ -1,86 +1,487 @@
 # frozen_string_literal: true
 
-require_relative 'base_command'
-require_relative '../registry'
-require_relative '../models/validation_result'
+require 'thor'
+require_relative '../definition/definition_validator'
+require_relative '../tool'
 
 module Ukiryu
   module CliCommands
-    # Schema validation command for tool profiles
-    class ValidateCommand < BaseCommand
-      # Execute the validate command
-      #
-      # @param tool_name [String, nil] the tool name (nil to validate all)
-      # @param options [Hash] command options
-      def run(tool_name = nil)
-        setup_registry
+    # Validate tool definitions
+    #
+    # The validate command checks tool definitions against JSON Schema
+    # and structural validation rules.
+    class ValidateCommand < Thor
+      class_option :verbose, type: :boolean, default: false
+      class_option :format, type: :string, default: 'text', enum: %w[text json]
+      class_option :schema, type: :string, desc: 'Path to JSON Schema file'
+      class_option :strict, type: :boolean, default: false, desc: 'Treat warnings as errors'
+      class_option :executable, type: :boolean, default: false, desc: 'Test executable against actual tool'
+      class_option :all, type: :boolean, default: false, desc: 'Enable all validations (schema + executable + smoke tests)'
+      class_option :register, type: :string, desc: 'Path to tool register'
 
-        if tool_name
-          validate_single_tool(tool_name)
-        else
-          validate_all_tools
-        end
+      desc 'file PATH', 'Validate a definition file'
+      def file(path)
+        validate_file(path)
+      end
+
+      desc 'all', 'Validate all definitions in register'
+      option :register, type: :string, desc: 'Register path'
+      def all
+        validate_all
+      end
+
+      desc 'string YAML', 'Validate a YAML string'
+      def string(yaml)
+        validate_string(yaml)
       end
 
       private
 
-      # Validate a single tool
+      # Validate a single file
       #
-      # @param tool_name [String] the tool name
-      def validate_single_tool(tool_name)
-        result = Registry.validate_tool(tool_name, registry_path: config.registry)
+      # @param path [String] file path
+      def validate_file(path)
+        validate_file_impl(path)
+      end
 
-        say "Validating tool: #{tool_name}", :cyan
+      # Validate a single file (implementation)
+      #
+      # @param path [String] file path
+      def validate_file_impl(path)
+        # First, validate the definition structure
+        result = Ukiryu::Definition::DefinitionValidator.validate_file(
+          path,
+          schema_path: options[:schema]
+        )
+
+        output_result(result, path)
+
+        # If structural validation passed and --executable or --all flag is set, test the executable
+        test_executable(path) if (options[:executable] || options[:all]) && result.valid?
+
+        exit 1 if result.invalid? || (result.has_warnings? && options[:strict])
+      end
+
+      # Test the executable against the actual tool
+      #
+      # @param path [String] path to definition file
+      def test_executable(path)
         say '', :clear
+        say 'Testing executable...', :cyan
+
+        begin
+          # Load the YAML profile to get smoke_tests
+          profile_data = YAML.safe_load(File.read(path), permitted_classes: [Symbol, Date, Time])
+
+          # Extract tool name from file path
+          file_name = File.basename(path, '.yaml')
+          tool_dir = File.basename(File.dirname(path))
+          tools_dir = File.basename(File.dirname(File.dirname(path)))
+
+          # The tool name is the directory name under tools/
+          tool_name = if tools_dir == 'tools'
+                        tool_dir
+                      else
+                        file_name
+                      end
+
+          # Don't hardcode register path - use options or let Tool.find handle it
+          tool_options = {}
+          tool_options[:register_path] = options[:register] if options[:register]
+
+          # Load the tool (Tool.get will find the right register path)
+          tool = Ukiryu::Tool.get(tool_name, **tool_options)
+
+          # Check if the tool is available
+          if tool.available?
+            say "✓ Tool found at: #{tool.executable}", :green
+          else
+            say '✗ Tool not found', :red
+            say "  Searched in: #{tool.search_paths.join(', ')}", :dim
+            exit 1
+          end
+
+          # Test version detection if defined
+          if tool.profile.version_detection
+            say '', :clear
+            say 'Testing version detection...', :cyan
+
+            begin
+              detected_version = tool.detect_version
+
+              if detected_version
+                say "✓ Version detected: #{detected_version}", :green
+              else
+                say '⚠ Version detection failed - could not extract version', :yellow
+              end
+            rescue StandardError => e
+              say "⚠ Version check failed: #{e.message}", :yellow
+            end
+          end
+
+          # Run smoke tests from profile if defined
+          smoke_tests = profile_data[:smoke_tests] || profile_data['smoke_tests']
+          if smoke_tests && !smoke_tests.empty?
+            say '', :clear
+            say "Running #{smoke_tests.length} smoke test(s)...", :cyan
+            run_smoke_tests(tool, smoke_tests, profile_data)
+          elsif tool.profile.profiles&.any?
+            # Fallback: test basic command execution if commands are defined
+            profile = tool.profile.profiles.first
+            if profile.commands && !profile.commands.empty?
+              say '', :clear
+              say 'Testing command execution (smoke test)...', :cyan
+
+              profile.commands.each do |cmd_def|
+                cmd_name = cmd_def.name
+                begin
+                  test_result = execute_smoke_test(tool, cmd_name)
+
+                  if test_result[:success]
+                    say "✓ Command '#{cmd_name}' is available", :green
+                  else
+                    say "⚠ Command '#{cmd_name}' test failed: #{test_result[:message]}", :yellow
+                  end
+                rescue StandardError => e
+                  say "⚠ Command '#{cmd_name}' test error: #{e.message}", :yellow
+                end
+
+                break
+              end
+            end
+          end
+        rescue Ukiryu::ToolNotFoundError => e
+          say "✗ Tool not found: #{e.message}", :red
+          exit 1
+        rescue StandardError => e
+          say "✗ Executable test failed: #{e.message}", :red
+          exit 1 if options[:strict]
+        end
+      end
+
+      # Run smoke tests from profile
+      #
+      # @param tool [Ukiryu::Tool] the tool instance
+      # @param smoke_tests [Array<Hash>] smoke test definitions
+      # @param profile_data [Hash] the loaded profile data
+      def run_smoke_tests(tool, smoke_tests, profile_data)
+        smoke_tests.each_with_index do |test, index|
+          test_name = test[:name] || test['name']
+          test_description = test[:description] || test['description'] || test_name
 
-        if result.valid?
-          say result.status_message, :green
-        else
-          say result.status_message, :red
           say '', :clear
-          result.errors.each do |error|
-            say "  - #{error}", :white
+          say "[#{index + 1}/#{smoke_tests.length}] #{test_name}: #{test_description}", :cyan
+
+          # Check platform filter
+          platforms = test[:platforms] || test['platforms']
+          current_platform = current_platform_symbol
+          if platforms && !platforms.include?(current_platform.to_s)
+            say "  ⊘ Skipped (not for this platform: #{current_platform})", :dim
+            next
+          end
+
+          # Check skip_if condition
+          skip_if = test[:skip_if] || test['skip_if']
+          if skip_if && evaluate_condition(skip_if, tool, profile_data)
+            say "  ⊘ Skipped (condition: #{skip_if})", :dim
+            next
+          end
+
+          # Get the command to run
+          test_command = test[:command] || test['command']
+          test_timeout = test[:timeout] || test['timeout'] || tool.profile.timeout || 30
+
+          begin
+            # Execute the test command
+            result = execute_test_command(tool, test_command, test_timeout)
+
+            # Validate the result
+            validation_result = validate_test_result(result, test)
+
+            if validation_result[:passed]
+              say "  ✓ PASSED", :green
+              if options[:verbose] && validation_result[:details]
+                validation_result[:details].each do |detail|
+                  say "    #{detail}", :dim
+                end
+              end
+            else
+              say "  ✗ FAILED", :red
+              validation_result[:errors].each do |error|
+                say "    ✗ #{error}", :red
+              end
+              exit 1 if options[:strict]
+            end
+          rescue StandardError => e
+            say "  ✗ ERROR: #{e.message}", :red
+            exit 1 if options[:strict]
           end
         end
+      end
+
+      # Execute a test command
+      #
+      # @param tool [Ukiryu::Tool] the tool instance
+      # @param test_command [String, Array] command to run
+      # @param timeout [Integer] timeout in seconds
+      # @return [Hash] execution result
+      def execute_test_command(tool, test_command, _timeout)
+        cmd_array = if test_command.is_a?(Array)
+                      test_command
+                    else
+                      # Parse command string into array (basic parsing)
+                      test_command.shellsplit
+                    end
+
+        # Build full command with tool executable
+        full_command = [tool.executable] + cmd_array
 
-        # Exit with error code if validation failed
-        exit(result.invalid? ? 1 : 0)
+        # Execute using Open3
+        require 'open3'
+        stdout_str, stderr_str, status = Open3.capture3(*full_command)
+
+        {
+          stdout: stdout_str,
+          stderr: stderr_str,
+          exit_code: status.exitstatus,
+          success: status.success?,
+          runtime: nil # TODO: add runtime measurement
+        }
       end
 
-      # Validate all tools
-      def validate_all_tools
-        results = Registry.validate_all_tools(registry_path: config.registry)
+      # Validate test result against expectations
+      #
+      # @param result [Hash] execution result
+      # @param test [Hash] test definition with expect section
+      # @return [Hash] validation result with :passed, :errors, :details
+      def validate_test_result(result, test)
+        errors = []
+        details = []
+        passed = true
+
+        expect = test[:expect] || test['expect'] || {}
 
-        say "Validating all tools in registry: #{config.registry}", :cyan
-        say '', :clear
+        # Check exit code
+        expected_exit_code = expect[:exit_code] || expect['exit_code'] || 0
+        if result[:exit_code] != expected_exit_code
+          errors << "Exit code mismatch: expected #{expected_exit_code}, got #{result[:exit_code]}"
+          passed = false
+        else
+          details << "Exit code: #{result[:exit_code]} (as expected)"
+        end
+
+        # Check output_match regex
+        output_match = expect[:output_match] || expect['output_match']
+        if output_match
+          regex = Regexp.new(output_match)
+          if result[:stdout] =~ regex
+            details << "Output matches pattern: #{output_match}"
+          else
+            errors << "Output does not match pattern: #{output_match}"
+            passed = false
+          end
+        end
+
+        # Check output_contains
+        output_contains = expect[:output_contains] || expect['output_contains']
+        if output_contains && !output_contains.empty?
+          output_contains.each do |str|
+            if result[:stdout].include?(str)
+              details << "Output contains: #{str}"
+            else
+              errors << "Output missing string: #{str}"
+              passed = false
+            end
+          end
+        end
+
+        # Check stderr_match regex
+        stderr_match = expect[:stderr_match] || expect['stderr_match']
+        if stderr_match
+          regex = Regexp.new(stderr_match)
+          if result[:stderr] =~ regex
+            details << "Stderr matches pattern: #{stderr_match}"
+          else
+            errors << "Stderr does not match pattern: #{stderr_match}"
+            passed = false
+          end
+        end
+
+        { passed: passed, errors: errors, details: details }
+      end
+
+      # Get current platform as symbol
+      #
+      # @return [Symbol] platform symbol
+      def current_platform_symbol
+        case RbConfig::CONFIG['host_os']
+        when /linux/i
+          :linux
+        when /darwin/i
+          :macos
+        when /mswin|mingw|cygwin/i
+          :windows
+        else
+          :unknown
+        end
+      end
 
-        valid_count = 0
-        invalid_count = 0
-        not_found_count = 0
+      # Evaluate skip condition (basic implementation)
+      #
+      # @param condition [String] condition string
+      # @param tool [Ukiryu::Tool] tool instance
+      # @param profile_data [Hash] profile data
+      # @return [Boolean] true if condition is met
+      def evaluate_condition(_condition, _tool, _profile_data)
+        # Very basic condition evaluation - can be expanded later
+        # For now, just return false to not skip any tests
+        false
+      end
 
-        results.each do |result|
-          say "#{result.tool_name.ljust(20)}: #{result.status_message}", result.valid? ? :green : :red
+      # Execute a simple smoke test for a command
+      #
+      # @param tool [Ukiryu::Tool] the tool instance
+      # @param cmd_name [Symbol] the command name
+      # @return [Hash] test result with :success and :message
+      def execute_smoke_test(tool, cmd_name)
+        # Try to get help for the command - most CLI tools support --help or -h
 
-          valid_count += 1 if result.valid?
-          invalid_count += 1 if result.invalid? && !result.not_found?
-          not_found_count += 1 if result.not_found?
+        # Try with empty arguments first, just to see if the command runs
+        result = tool.execute(cmd_name, {})
 
-          # Show errors for invalid tools
-          if result.invalid? && !result.not_found?
+        # If we get here, the command executed
+        # Check for common error patterns
+        if result.exit_status.zero?
+          { success: true, message: 'Command executed successfully' }
+        elsif result.stderr.include?('unrecognized') || result.stderr.include?('unknown')
+          { success: false, message: 'Command not recognized by tool' }
+        else
+          { success: true, message: "Command executed (exit code: #{result.exit_status})" }
+        end
+      rescue Ukiryu::ExecutionError => e
+        if e.result.stderr.include?('unrecognized') || e.result.stderr.include?('unknown')
+          { success: false, message: 'Command not recognized by tool' }
+        else
+          { success: false, message: e.message }
+        end
+      end
+
+      # Validate all definitions in register
+      def validate_all
+        require_relative '../register_auto_manager'
+
+        register_path = Ukiryu::RegisterAutoManager.register_path
+        return say_error("Register not found: #{register_path}") unless Dir.exist?(register_path)
+
+        tools_dir = File.join(register_path, 'tools')
+        return say_error("Tools directory not found: #{tools_dir}") unless Dir.exist?(tools_dir)
+
+        results = {}
+        yaml_files = Dir.glob(File.join(tools_dir, '*', '*.yaml')).sort
+
+        say "Validating #{yaml_files.length} tool definitions...", :cyan
+        say '', :clear
+
+        yaml_files.each do |file|
+          # Get relative path from tools directory
+          relative_path = file.sub("#{tools_dir}/", '')
+
+          result = Ukiryu::Definition::DefinitionValidator.validate_file(
+            file,
+            schema_path: options[:schema]
+          )
+          results[file] = result
+
+          # Show file and result on same line
+          if result.valid?
+            status = result.has_warnings? ? '✓ VALID (with warnings)' : '✓ VALID'
+            say "  #{relative_path.ljust(35)} #{status}", result.has_warnings? ? :yellow : :green
+          else
+            say "  #{relative_path.ljust(35)} ✗ INVALID", :red
             result.errors.each do |error|
-              say "  - #{error}", :dim
+              say "    - #{error}", :red
             end
           end
+
+          next unless result.has_warnings?
+
+          result.warnings.each do |warning|
+            say "    ⚠ #{warning}", :yellow
+          end
         end
 
+        # Summary
         say '', :clear
-        say "Summary:", :cyan
-        say "  Valid:   #{valid_count}", :green
-        say "  Invalid: #{invalid_count}", invalid_count > 0 ? :red : :white
-        say "  Missing: #{not_found_count}", not_found_count > 0 ? :yellow : :white
+        total = results.length
+        valid = results.values.count(&:valid?)
+        invalid = results.values.count(&:invalid?)
 
-        # Exit with error code if any validations failed
-        exit(invalid_count > 0 ? 1 : 0)
+        say 'Validation Summary:', :cyan
+        say "  Total:   #{total}", :white
+        say "  Valid:   #{valid}", :green
+        say "  Invalid: #{invalid}", invalid.zero? ? :green : :red
+
+        exit 1 if invalid.positive?
+      end
+
+      # Validate a YAML string
+      #
+      # @param yaml_string [String] YAML content
+      def validate_string(yaml_string)
+        result = Ukiryu::Definition::DefinitionValidator.validate_string(
+          yaml_string,
+          schema_path: options[:schema]
+        )
+
+        output_result(result, '<string>')
+        exit 1 if result.invalid? || (result.has_warnings? && options[:strict])
+      end
+
+      # Output validation result
+      #
+      # @param result [ValidationResult] validation result
+      # @param source [String] source identifier
+      def output_result(result, source)
+        case options[:format]
+        when 'json'
+          say result.to_json, :white
+        else
+          output_text(result, source)
+        end
+      end
+
+      # Output as text
+      #
+      # @param result [ValidationResult] validation result
+      # @param source [String] source identifier
+      def output_text(result, source)
+        say "Validating: #{source}", :cyan
+
+        if result.valid?
+          if result.has_warnings?
+            say '✓ Valid with warnings', :yellow
+            say '', :clear
+            result.warnings.each { |w| say "  Warning: #{w}", :yellow }
+          else
+            say '✓ Valid', :green
+          end
+        else
+          say '✗ Invalid', :red
+          say '', :clear
+          result.errors.each { |e| say "  Error: #{e}", :red }
+          if result.has_warnings?
+            say '', :clear
+            result.warnings.each { |w| say "  Warning: #{w}", :yellow }
+          end
+        end
+      end
+
+      # Show error message
+      #
+      # @param message [String] error message
+      def say_error(message)
+        say message, :red
+        exit 1
       end
     end
   end

data/lib/ukiryu/cli_commands/which_command.rb

@@ -13,7 +13,7 @@ module Ukiryu
       #
       # @param identifier [String] the tool name, interface, or alias
       def run(identifier)
-        setup_registry
+        setup_register
 
         runtime = Runtime.instance
         platform = options[:platform] || runtime.platform
@@ -34,7 +34,7 @@ module Ukiryu
         if tool
           show_selected_tool(tool, identifier, platform, shell)
         else
-          error! "No tool found for: #{identifier}\nAvailable tools: #{Registry.tools.sort.join(', ')}"
+          error! "No tool found for: #{identifier}\nAvailable tools: #{Register.tools.sort.join(', ')}"
         end
       end
 
@@ -61,12 +61,12 @@ module Ukiryu
       # @param shell [Symbol] the shell
       # @return [Tool, nil] the tool or nil if not found
       def try_interface_discovery(identifier, platform, shell)
-        require_relative '../registry'
+        require_relative '../register'
 
         candidates = []
 
-        Registry.tools.each do |tool_name|
-          tool_metadata = Registry.load_tool_metadata(tool_name.to_sym)
+        Register.tools.each do |tool_name|
+          tool_metadata = Register.load_tool_metadata(tool_name.to_sym)
           next unless tool_metadata
 
           # Check for interface match