ukiryu 0.1.0 → 0.1.1

data/lib/ukiryu/cli_commands/exec_inline_command.rb.fixed

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+require_relative '../tool'
+require_relative '../executor'
+require 'yaml'
+
+module Ukiryu
+  module CliCommands
+      # Execute a tool command inline (shorthand for run)
+    class ExecInlineCommand < BaseCommand
+        # Supported output formats
+        OUTPUT_FORMATS = %i[yaml json].freeze
+
+        # Execute the command
+        #
+        # @param tool_name [String] the tool name
+        # @param command_name [String] the command name
+        # @param params [Array<String>] key=value parameter pairs
+      def run(tool_name, command_name, *params)
+          setup_registry
+
+          # Parse key=value pairs into arguments hash
+          arguments = parse_inline_params(params)
+
+          # Build execution request
+          request = {
+            'tool' => tool_name,
+            'command' => command_name,
+            'arguments' => arguments
+          }
+
+          # Validate format option
+          format = (options[:format] || 'yaml').to_sym
+          error! "Invalid format: #{options[:format]}. Must be one of: #{OUTPUT_FORMATS.join(', ')}" unless OUTPUT_FORMATS.include?(format)
+
+          if options[:dry_run]
+            # Show dry run output
+            say_dry_run(request)
+            return
+          end
+
+          # Execute the request
+          response = execute_request(request)
+
+          # Output response
+          output_response(response, format, nil)
+
+          # Exit with error code if command failed
+          exit_code = response['exit_code'].to_i
+          exit(exit_code) if exit_code != 0
+        end
+
+        private
+
+        # Parse inline key=value params into a hash
+      def parse_inline_params(params_array)
+          arguments = {}
+
+          params_array.each do |param|
+            if param.include?('=')
+              key, value = param.split('=', 2)
+
+              # Try to parse value as YAML to handle types properly
+              begin
+                parsed_value = YAML.safe_load(value, permitted_classes: [Symbol])
+                value = parsed_value
+              rescue StandardError
+                # Keep as string if YAML parsing fails
+              end
+
+              # Convert key to symbol for consistency with API
+              arguments[key.to_sym] = value
+            else
+              error! "Invalid parameter format: #{param}. Use key=value"
+            end
+          end
+
+          arguments
+        end
+
+        # Execute the request and build response
+      def execute_request(request)
+          tool_name = request['tool']
+          command_name = request['command']
+          arguments = stringify_keys(request['arguments'])
+
+          begin
+            # Get tool
+            tool = Tool.get(tool_name.to_sym)
+            return build_error_response("Tool not available: #{tool_name}") unless tool.available?
+
+            # Build options object (OOP approach)
+            options_class = tool.options_for(command_name.to_sym)
+            options = options_class.new
+            arguments.each { |key, value| options.send("#{key}=", value) }
+
+            # Execute command
+            result = tool.execute(command_name.to_sym, options)
+
+            # Build successful response
+            build_success_response(result)
+          rescue Ukiryu::ToolNotFoundError => e
+            build_error_response("Tool not found: #{e.message}")
+          rescue Ukiryu::ProfileNotFoundError => e
+            build_error_response("Profile not found: #{e.message}")
+          rescue Ukiryu::ExecutionError => e
+            build_error_response(e.message)
+          rescue Ukiryu::TimeoutError => e
+            build_error_response("Command timed out: #{e.message}")
+          rescue ArgumentError => e
+            build_error_response("Invalid arguments: #{e.message}")
+          rescue StandardError => e
+            build_error_response("Unexpected error: #{e.class}: #{e.message}")
+          end
+        end
+
+        # Build success response from Result object
+      def build_success_response(result)
+          {
+            'status' => 'success',
+            'exit_code' => result.status,
+            'command' => {
+              'executable' => result.executable,
+              'arguments' => result.command_info.arguments,
+              'full_command' => result.command_info.full_command,
+              'shell' => result.command_info.shell.to_s
+            },
+            'output' => {
+              'stdout' => result.stdout,
+              'stderr' => result.error_output,
+              'stdout_lines' => result.stdout_lines,
+              'stderr_lines' => result.stderr_lines
+            },
+            'metadata' => {
+              'started_at' => result.started_at.iso8601,
+              'finished_at' => result.finished_at.iso8601,
+              'duration_seconds' => result.duration,
+              'formatted_duration' => result.metadata.formatted_duration
+            }
+          }
+        end
+
+        # Build error response
+      def build_error_response(message)
+          {
+            'status' => 'error',
+            'exit_code' => 1,
+            'error' => message
+          }
+        end
+
+        # Output response in specified format
+      def output_response(response, format, _output_file)
+          output_string = case format
+                          when :yaml
+                            response.to_yaml
+                          when :json
+                            require 'json'
+                            JSON.pretty_generate(response)
+                          end
+
+          say output_string
+        end
+
+        # Show dry run output
+      def say_dry_run(request)
+          say 'DRY RUN - Ukiryu Structured Execution Request:', :yellow
+          say '', :clear
+          say "Tool: #{request['tool']}", :cyan
+          say "Command: #{request['command']}", :cyan
+          say 'Arguments:', :cyan
+          request['arguments'].each do |key, value|
+            say "  #{key}: #{value.inspect}", :white
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ukiryu/cli_commands/extract_command.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+require_relative '../extractors/extractor'
+
+module Ukiryu
+  module CliCommands
+    # Extract tool definition from an installed CLI tool
+    #
+    # This command attempts to extract a tool definition by:
+    # 1. Trying the tool's native --ukiryu-definition flag
+    # 2. Parsing the tool's --help output as a fallback
+    class ExtractCommand < BaseCommand
+      # Execute the extract command
+      #
+      # @param tool_name [String] the tool name to extract definition from
+      def run(tool_name)
+        result = Extractors::Extractor.extract(tool_name, extract_options)
+
+        if result[:success]
+          output_result(result)
+        else
+          handle_failure(result)
+        end
+      end
+
+      private
+
+      # Build extraction options from CLI options
+      #
+      # @return [Hash] extraction options
+      def extract_options
+        {
+          method: options[:method]&.to_sym || :auto,
+          verbose: options[:verbose]
+        }
+      end
+
+      # Output the extracted definition
+      #
+      # @param result [Hash] extraction result
+      def output_result(result)
+        yaml_content = result[:yaml]
+
+        # Write to file if output option specified
+        if options[:output]
+          File.write(options[:output], yaml_content)
+          say "Definition extracted to: #{options[:output]}", :green
+          say "Method: #{result[:method]}", :cyan if options[:verbose]
+        else
+          # Output to stdout
+          puts yaml_content
+          say "\n# Extracted using: #{result[:method]}", :cyan if options[:verbose]
+        end
+      end
+
+      # Handle extraction failure
+      #
+      # @param result [Hash] extraction result
+      def handle_failure(result)
+        say "Failed to extract definition from '#{@tool_name}'", :red
+        say "Error: #{result[:error]}", :red
+        say '', :clear
+        say 'The tool may not be installed or may not support extraction.', :yellow
+        say '', :clear
+        say 'Extraction methods tried:', :yellow
+
+        if options[:method] && options[:method] != 'auto'
+          say "  - #{options[:method]} (explicitly selected)", :white
+        else
+          say "  - native (try --ukiryu-definition flag)", :white
+          say "  - help (parse --help output)", :white
+        end
+
+        say '', :clear
+        say 'You can specify a method with --method:', :yellow
+        say '  ukiryu extract TOOL --method native', :white
+        say '  ukiryu extract TOOL --method help', :white
+
+        exit 1
+      end
+    end
+  end
+end

data/lib/ukiryu/cli_commands/info_command.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+require_relative '../tool'
+
+module Ukiryu
+  module CliCommands
+    # Show detailed information about a tool
+    class InfoCommand < BaseCommand
+      # Execute the info command
+      #
+      # @param tool_name [String] the tool name
+      def run(tool_name)
+        setup_registry
+
+        # Use find_by for interface-based discovery (ping -> ping_bsd/ping_gnu)
+        tool = Tool.find_by(tool_name.to_sym)
+        error!("Tool not found: #{tool_name}\nAvailable tools: #{Registry.tools.sort.join(', ')}") unless tool
+
+        profile = tool.profile
+        show_all = options[:all]
+
+        say '', :clear
+
+        # Show interface information if queried name differs from actual tool name
+        if profile.name != tool_name.to_s && profile.implements
+          say "Interface: #{tool_name}", :cyan
+          say "  This tool implements the '#{tool_name}' interface", :dim
+          say "  Tool: #{profile.name}", :white
+
+          # Find other implementations of this interface
+          other_implementations = find_other_implementations(tool_name.to_s, profile.name)
+          say "  Other implementations: #{other_implementations.join(', ')}", :dim if other_implementations.any?
+
+          if show_all
+            say '', :clear
+            say "All '#{tool_name}' implementations:", :yellow
+            all_implementations = [profile.name, *other_implementations].sort
+            all_implementations.each do |impl|
+              impl_tool = Tool.get(impl)
+              if impl_tool
+                status = impl_tool.available? ? '[✓]' : '[✗]'
+                color = impl_tool.available? ? :green : :red
+                say "  #{status.ljust(4)} #{impl}", color
+              else
+                say "  [?] #{impl}", :white
+              end
+            rescue Ukiryu::ToolNotFoundError, Ukiryu::ProfileNotFoundError
+              # Tool exists but no compatible profile for this platform
+              say "  [ ] #{impl}", :dim
+            end
+          end
+        else
+          say "Tool: #{profile.name || tool_name}", :cyan
+        end
+
+        say "Display Name: #{profile.display_name || 'N/A'}", :white
+        say "Version: #{profile.version || 'N/A'}", :white
+        say "Homepage: #{profile.homepage || 'N/A'}", :white
+
+        say "Aliases: #{profile.aliases.join(', ')}", :white if profile.aliases && !profile.aliases.empty?
+
+        # Version detection
+        if profile.version_detection
+          vd = profile.version_detection
+          say '', :clear
+          say 'Version Detection:', :yellow
+          command_display = vd.command.is_a?(Array) ? vd.command.join(' ') : vd.command
+          say "  Command: #{command_display}", :white
+          say "  Pattern: #{vd.pattern}", :white
+          say "  Modern Threshold: #{vd.modern_threshold}", :white if vd.modern_threshold
+        end
+
+        # Search paths
+        if profile.search_paths
+          say '', :clear
+          say 'Search Paths:', :yellow
+          search_paths = profile.search_paths
+
+          # Iterate over platform attributes
+          %i[macos linux windows freebsd openbsd netbsd].each do |platform|
+            paths = search_paths.send(platform)
+            next if paths.nil? || paths.empty?
+
+            say "  #{platform}:", :white
+            Array(paths).each { |p| say "    - #{p}", :white }
+          end
+        end
+
+        # Profiles
+        if profile.profiles
+          say '', :clear
+          say "Profiles (#{profile.profiles.count}):", :yellow
+          profile.profiles.each do |prof|
+            platforms = Array(prof.platforms || ['all']).join(', ')
+            shells = Array(prof.shells || ['all']).join(', ')
+            option_style = prof.option_style || 'default'
+            say "  #{prof.name || 'unnamed'}:", :white
+            say "    Platforms: #{platforms}", :white
+            say "    Shells: #{shells}", :white
+            say "    Option Style: #{option_style}", :white
+            say "    Inherits: #{prof.inherits || 'none'}", :white if prof.inherits
+          end
+        end
+
+        # Availability
+        say '', :clear
+        if tool.available?
+          say 'Status: INSTALLED', :green
+          say "Executable: #{tool.executable}", :white
+          say "Detected Version: #{tool.version || 'unknown'}", :white
+        else
+          say 'Status: NOT FOUND', :red
+        end
+      end
+
+      private
+
+      # Find other tools that implement the same interface
+      #
+      # @param interface_name [String] the interface name
+      # @param current_tool_name [String] the current tool name to exclude
+      # @return [Array<String>] list of other tool names
+      def find_other_implementations(interface_name, current_tool_name)
+        require_relative '../registry'
+
+        implementations = []
+        interface_sym = interface_name.to_sym
+
+        if config.debug
+          say "  [DEBUG] Looking for tools implementing '#{interface_name}' (excluding '#{current_tool_name}')", :dim
+          say "  [DEBUG] Registry tools: #{Registry.tools.inspect}", :dim
+        end
+
+        Registry.tools.each do |tool_name|
+          next if tool_name == current_tool_name
+
+          begin
+            # Don't pass registry_path - let it use the default
+            tool_metadata = Registry.load_tool_metadata(tool_name.to_sym)
+            if config.debug
+              say "  [DEBUG] #{tool_name} -> metadata: #{tool_metadata ? tool_metadata.implements : 'nil'}", :dim
+            end
+            implementations << tool_name if tool_metadata && tool_metadata.implements == interface_sym
+          rescue StandardError => e
+            # Skip tools that fail to load
+            say "  [DEBUG] Failed to load #{tool_name}: #{e.message}", :dim if config.debug
+            next
+          end
+        end
+
+        implementations.sort
+      end
+    end
+  end
+end

data/lib/ukiryu/cli_commands/list_command.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+require_relative '../tool'
+require_relative '../registry'
+
+module Ukiryu
+  module CliCommands
+    # List all available tools in the registry
+    class ListCommand < BaseCommand
+      # Execute the list command
+      def run
+        setup_registry
+
+        tools = Registry.tools
+        error! 'No tools found in registry' if tools.empty?
+
+        say "Available tools (#{tools.count}):", :cyan
+
+        # Separate tools into interfaces and standalone tools
+        interfaces = {}
+        standalone_tools = []
+
+        tools.sort.each do |name|
+          metadata = Registry.load_tool_metadata(name.to_sym)
+
+          if metadata&.implements
+            # This tool implements an interface
+            interface_name = metadata.implements.to_s
+            interfaces[interface_name] ||= []
+            interfaces[interface_name] << name
+          elsif metadata&.aliases&.any?
+            # Tool has aliases but doesn't implement interface - treat as standalone
+            standalone_tools << name
+          else
+            # Regular standalone tool
+            standalone_tools << name
+          end
+        rescue Ukiryu::Error
+          # If we can't load metadata, treat as standalone
+          standalone_tools << name
+        end
+
+        # Display interfaces first
+        interfaces.sort.each do |interface_name, impls|
+          say "  #{interface_name}:", :cyan
+
+          impls.sort.each do |impl_name|
+            tool = Tool.get(impl_name)
+            version_info = tool.version ? "v#{tool.version}" : 'version unknown'
+            available = tool.available? ? '[✓]' : '[✗]'
+            say "    #{available.ljust(4)} #{impl_name.ljust(20)} #{version_info}", tool.available? ? :green : :red
+          rescue Ukiryu::Error => e
+            say "    [?] #{impl_name.ljust(20)} error: #{e.message}", :red
+          end
+        end
+
+        # Display standalone tools
+        standalone_tools.sort.each do |name|
+          tool = Tool.get(name)
+          version_info = tool.version ? "v#{tool.version}" : 'version unknown'
+          available = tool.available? ? '[✓]' : '[✗]'
+          say "  #{available.ljust(4)} #{name.ljust(20)} #{version_info}", tool.available? ? :green : :red
+        rescue Ukiryu::Error => e
+          say "  [?] #{name.ljust(20)} error: #{e.message}", :red
+        end
+      end
+    end
+  end
+end

data/lib/ukiryu/cli_commands/opts_command.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+require_relative '../tool'
+
+module Ukiryu
+  module CliCommands
+    # Show options for a tool or specific command
+    class OptsCommand < BaseCommand
+      # Execute the opts command
+      #
+      # @param tool_name [String] the tool name
+      # @param command_name [String, nil] optional command name
+      def run(tool_name, command_name = nil)
+        setup_registry
+
+        # Use find_by for interface-based discovery (ping -> ping_bsd/ping_gnu)
+        tool = Tool.find_by(tool_name.to_sym)
+        error!("Tool not found: #{tool_name}\nAvailable tools: #{Registry.tools.sort.join(', ')}") unless tool
+
+        tool_commands = tool.commands
+        error! "No commands defined for #{tool_name}" unless tool_commands
+
+        # Find the command
+        cmds = if command_name
+                 tool_commands.find { |c| c.name.to_s == command_name.to_s || c.name.to_sym == command_name.to_sym }
+                 cmds ? [cmds] : []
+               else
+                 tool_commands
+               end
+
+        cmds.each do |cmd|
+          cmd_title = command_name ? "#{tool_name} #{command_name}" : tool_name
+          say '', :clear
+          say "Options for #{cmd_title}:", :cyan
+          say cmd.description.to_s if cmd.description
+
+          # Arguments
+          if cmd.arguments && !cmd.arguments.empty?
+            say '', :clear
+            say 'Arguments:', :yellow
+            cmd.arguments.each do |arg|
+              name = arg.name || 'unnamed'
+              type = arg.type || 'unknown'
+              position = arg.position || 'default'
+              variadic = arg.variadic ? '(variadic)' : ''
+
+              say "  #{name} (#{type}#{variadic})", :white
+              say "    Position: #{position}", :dim if position != 'default'
+              say "    Description: #{arg.description}", :dim if arg.description
+            end
+          end
+
+          # Options
+          if cmd.options && !cmd.options.empty?
+            say '', :clear
+            say 'Options:', :yellow
+            cmd.options.each do |opt|
+              name = opt.name || 'unnamed'
+              cli = opt.cli || 'N/A'
+              type = opt.type || 'unknown'
+              description = opt.description || ''
+
+              say "  --#{name.ljust(20)} #{cli}", :white
+              say "    Type: #{type}", :dim
+              say "    #{description}", :dim if description
+              say "    Values: #{opt.values.join(', ')}", :dim if opt.values
+              say "    Range: #{opt.range.join('..')}", :dim if opt.range
+            end
+          end
+
+          # Post-options (options between input and output)
+          if cmd.post_options && !cmd.post_options.empty?
+            say '', :clear
+            say 'Post-Options (between input and output):', :yellow
+            cmd.post_options.each do |opt|
+              name = opt.name || 'unnamed'
+              cli = opt.cli || 'N/A'
+              type = opt.type || 'unknown'
+              description = opt.description || ''
+
+              say "  --#{name.ljust(20)} #{cli}", :white
+              say "    Type: #{type}", :dim
+              say "    #{description}", :dim if description
+            end
+          end
+
+          # Flags
+          next unless cmd.flags && !cmd.flags.empty?
+
+          say '', :clear
+          say 'Flags:', :yellow
+          cmd.flags.each do |flag|
+            name = flag.name || 'unnamed'
+            cli = flag.cli || 'N/A'
+            default = flag.default
+            default_str = default.nil? ? '' : " (default: #{default})"
+
+            say "  #{cli.ljust(25)} #{name}#{default_str}", :white
+            say "    #{flag.description}", :dim if flag.description
+          end
+        end
+      end
+    end
+  end
+end