ukiryu 0.1.0 → 0.1.1

data/lib/ukiryu/cli.rb

@@ -1,348 +1,174 @@
 # frozen_string_literal: true
 
-require "thor"
-require "ukiryu"
-require_relative "version"
+require 'thor'
+require_relative 'cli_commands/base_command'
+require_relative 'cli_commands/run_file_command'
+require_relative 'cli_commands/run_command'
+require_relative 'cli_commands/list_command'
+require_relative 'cli_commands/info_command'
+require_relative 'cli_commands/commands_command'
+require_relative 'cli_commands/opts_command'
+require_relative 'cli_commands/describe_command'
+require_relative 'cli_commands/which_command'
+require_relative 'cli_commands/config_command'
+require_relative 'cli_commands/version_command'
+require_relative 'cli_commands/system_command'
+require_relative 'cli_commands/validate_command'
+require_relative 'cli_commands/extract_command'
+require_relative 'thor_ext'
+require_relative 'version'
 
 module Ukiryu
   # CLI for exploring and interacting with Ukiryu tool profiles
+  #
+  # Each command is implemented as a separate class in the CliCommands::Commands namespace.
+  # This file just delegates to those command classes, keeping each file under 200 lines.
   class Cli < Thor
-    package_name "ukiryu"
+    package_name 'ukiryu'
+
+    # Extend FriendlyCLI for better Thor behavior
+    extend FriendlyCLI
 
     # Set default registry path if not configured
     def self.exit_on_failure?
       false
     end
 
-    desc "list", "List all available tools in the registry"
-    method_option :registry, aliases: :r, desc: "Path to tool registry", type: :string
-    def list
-      setup_registry(options[:registry])
-
-      tools = Registry.tools
-      if tools.empty?
-        say "No tools found in registry", :red
-        return
-      end
-
-      say "Available tools (#{tools.count}):", :cyan
-      tools.sort.each do |name|
-        begin
-          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
+    desc 'run-file REQUEST_FILE', 'Execute a Ukiryu Structured Execution Request from a YAML file'
+    method_option :registry, aliases: :r, desc: 'Path to tool registry', type: :string
+    method_option :output, aliases: :o, desc: 'Output file for response (default: stdout)', type: :string
+    method_option :format, aliases: :f, desc: 'Response format (yaml, json, table, raw)', type: :string, default: 'yaml'
+    method_option :dry_run, aliases: :d, desc: 'Show execution request without executing', type: :boolean,
+                            default: false
+    method_option :shell, desc: 'Shell to use for command execution (bash, zsh, fish, sh, powershell, cmd)', type: :string
+    def run_file(request_file)
+      CliCommands::RunFileCommand.new(options).run(request_file)
     end
 
-    desc "info TOOL", "Show detailed information about a tool"
-    method_option :registry, aliases: :r, desc: "Path to tool registry", type: :string
-    def info(tool_name)
-      setup_registry(options[:registry])
-
-      tool = Tool.get(tool_name)
-      profile = tool.profile
-
-      say "", :clear
-      say "Tool: #{profile[:name] || tool_name}", :cyan
-      say "Display Name: #{profile[:display_name] || 'N/A'}", :white
-      say "Version: #{profile[:version] || 'N/A'}", :white
-      say "Homepage: #{profile[:homepage] || 'N/A'}", :white
-
-      if profile[:aliases] && !profile[:aliases].empty?
-        say "Aliases: #{profile[:aliases].join(', ')}", :white
-      end
-
-      # Version detection
-      if profile[:version_detection]
-        vd = profile[:version_detection]
-        say "", :clear
-        say "Version Detection:", :yellow
-        say "  Command: #{vd[:command]}", :white
-        say "  Pattern: #{vd[:pattern]}", :white
-        if vd[:modern_threshold]
-          say "  Modern Threshold: #{vd[:modern_threshold]}", :white
-        end
-      end
-
-      # Search paths
-      if profile[:search_paths]
-        say "", :clear
-        say "Search Paths:", :yellow
-        profile[:search_paths].each do |platform, paths|
-          next if paths.nil? || paths.empty?
-          say "  #{platform}:", :white
-          Array(paths).each { |p| say "    - #{p}", :white }
-        end
-      end
+    desc 'exec TOOL [COMMAND] [KEY=VALUE ...]', 'Execute a tool command inline'
+    method_option :registry, aliases: :r, desc: 'Path to tool registry', type: :string
+    method_option :format, aliases: :f, desc: 'Response format (yaml, json, table, raw)', type: :string, default: 'yaml'
+    method_option :output, aliases: :o, desc: 'Output file for response (default: stdout)', type: :string
+    method_option :dry_run, aliases: :d, desc: 'Show execution request without executing', type: :boolean,
+                            default: false
+    method_option :shell, desc: 'Shell to use for command execution (bash, zsh, fish, sh, powershell, cmd)', type: :string
+    method_option :stdin, desc: 'Read input from stdin (pass to command)', type: :boolean, default: false
+    method_option :raw, desc: 'Output raw stdout/stderr (for pipe composition)', type: :boolean, default: false
+    def exec(tool_name, command_name = nil, *params)
+      CliCommands::RunCommand.new(options).run(tool_name, command_name, *params)
+    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(', ')
-          say "  #{prof[:name] || 'unnamed'}:", :white
-          say "    Platforms: #{platforms}", :white
-          say "    Shells: #{shells}", :white
-          say "    Version: #{prof[:version] || 'any'}", :white
-        end
-      end
+    desc 'list', 'List all available tools in the registry'
+    method_option :registry, aliases: :r, desc: 'Path to tool registry', type: :string
+    def list
+      CliCommands::ListCommand.new(options).run
+    end
 
-      # Availability
-      say "", :clear
-      if tool.available?
-        say "Status: INSTALLED", :green
-        say "Executable: #{tool.executable}", :white
-        say "Detected Version: #{tool.version || 'unknown'}", :white
+    desc 'info [TOOL]', 'Show detailed information about a tool (or general info if no tool specified)'
+    method_option :registry, aliases: :r, desc: 'Path to tool registry', type: :string
+    method_option :all, desc: 'Show all implementations for interfaces', type: :boolean, default: false
+    def info(tool_name = nil)
+      if tool_name.nil?
+        # Show general info when no tool specified
+        show_general_info
       else
-        say "Status: NOT FOUND", :red
+        CliCommands::InfoCommand.new(options).run(tool_name)
       end
     end
 
-    desc "commands TOOL", "List all commands available for a tool"
-    method_option :registry, aliases: :r, desc: "Path to tool registry", type: :string
+    desc 'commands TOOL', 'List all commands available for a tool'
+    method_option :registry, aliases: :r, desc: 'Path to tool registry', type: :string
     def commands(tool_name)
-      setup_registry(options[:registry])
-
-      tool = Tool.get(tool_name)
-      commands = tool.commands
-
-      unless commands
-        say "No commands defined for #{tool_name}", :red
-        return
-      end
-
-      say "Commands for #{tool_name}:", :cyan
-      commands.each do |cmd_name, cmd|
-        cmd_name = cmd_name || 'unnamed'
-        description = cmd[:description] || 'No description'
-        say "  #{cmd_name.to_s.ljust(20)} #{description}", :white
-
-        # Show usage if available
-        if cmd[:usage]
-          say "    Usage: #{cmd[:usage]}", :dim
-        end
-
-        # Show subcommand if exists
-        if cmd[:subcommand]
-          subcommand_info = cmd[:subcommand].nil? ? '(none)' : cmd[:subcommand]
-          say "    Subcommand: #{subcommand_info}", :dim
-        end
-      end
+      CliCommands::CommandsCommand.new(options).run(tool_name)
     end
 
-    desc "opts TOOL [COMMAND]", "Show options for a tool or specific command"
-    method_option :registry, aliases: :r, desc: "Path to tool registry", type: :string
+    desc 'opts TOOL [COMMAND]', 'Show options for a tool or specific command'
+    method_option :registry, aliases: :r, desc: 'Path to tool registry', type: :string
     def opts(tool_name, command_name = nil)
-      setup_registry(options[:registry])
-
-      tool = Tool.get(tool_name)
-      commands = tool.commands
-
-      unless commands
-        say "No commands defined for #{tool_name}", :red
-        return
-      end
-
-      # Find the command
-      cmds = if command_name
-                cmd = commands[command_name.to_sym] || commands[command_name]
-                cmd ? [cmd] : []
-              else
-                commands.values
-              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]}" 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
-            if opt[:values]
-              say "    Values: #{opt[:values].join(', ')}", :dim
-            end
-            if opt[:range]
-              say "    Range: #{opt[:range].join('..')}", :dim
-            end
-          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
-        if 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
+      CliCommands::OptsCommand.new(options).run(tool_name, command_name)
     end
 
-    desc "execute TOOL COMMAND [OPTIONS]", "Execute a tool command with options"
-    method_option :registry, aliases: :r, desc: "Path to tool registry", type: :string
-    method_option :inputs, aliases: :i, desc: "Input files", type: :array
-    method_option :output, aliases: :o, desc: "Output file", type: :string
-    method_option :dry_run, aliases: :d, desc: "Show command without executing", type: :boolean, default: false
-    def execute(tool_name, command_name, **extra_opts)
-      setup_registry(options[:registry])
-
-      tool = Tool.get(tool_name)
-
-      # Build params from options
-      params = {}
-      params[:inputs] = options[:inputs] if options[:inputs]
-      params[:output] = options[:output] if options[:output]
-
-      # Add extra options as params
-      extra_opts.each do |key, value|
-        params[key.to_sym] = value
-      end
-
-      if options[:dry_run]
-        # Show what would be executed without actually running
-        say "DRY RUN - Would execute:", :yellow
-        say "  Tool: #{tool_name}", :white
-        say "  Command: #{command_name}", :white
-        say "  Parameters:", :white
-        params.each do |k, v|
-          say "    #{k}: #{v.inspect}", :dim
-        end
-      else
-        result = tool.execute(command_name.to_sym, params)
-
-        if result.success?
-          say "Command completed successfully", :green
-          say "Exit status: #{result.status}", :white
-          say "Duration: #{result.metadata.formatted_duration}", :white
-
-          if result.output.stdout && !result.output.stdout.empty?
-            say "", :clear
-            say "STDOUT:", :yellow
-            say result.output.stdout
-          end
-
-          if result.output.stderr && !result.output.stderr.empty?
-            say "", :clear
-            say "STDERR:", :yellow
-            say result.output.stderr
-          end
-        else
-          say "Command failed", :red
-          say "Exit status: #{result.status}", :white
-          say "Duration: #{result.metadata.formatted_duration}", :white
-
-          if result.output.stdout && !result.output.stdout.empty?
-            say "", :clear
-            say "STDOUT:", :yellow
-            say result.output.stdout
-          end
-
-          if result.output.stderr && !result.output.stderr.empty?
-            say "", :clear
-            say "STDERR:", :yellow
-            say result.output.stderr
-          end
+    desc 'describe TOOL [COMMAND]', 'Show comprehensive documentation for a tool or specific command'
+    method_option :registry, aliases: :r, desc: 'Path to tool registry', type: :string
+    method_option :format, aliases: :f, desc: 'Output format (text, yaml, json)', type: :string, default: 'text'
+    def describe(tool_name, command_name = nil)
+      CliCommands::DescribeCommand.new(options).run(tool_name, command_name)
+    end
 
-          exit 1
-        end
-      end
+    desc 'system [SUBCOMMAND]', 'Show system information (shells, etc.)'
+    method_option :registry, aliases: :r, desc: 'Path to tool registry', type: :string
+    def system(subcommand = nil)
+      CliCommands::SystemCommand.new(options).run(subcommand)
     end
 
-    desc "version", "Show Ukiryu version"
+    desc 'version', 'Show Ukiryu version'
     def version
-      say "Ukiryu version #{Ukiryu::VERSION}", :cyan
+      CliCommands::VersionCommand.new(options).run
     end
 
-    private
-
-    def setup_registry(custom_path)
-      registry_path = custom_path ||
-                       ENV['UKIRYU_REGISTRY'] ||
-                       default_registry_path
-      if registry_path && Dir.exist?(registry_path)
-        Registry.default_registry_path = registry_path
-      end
+    desc 'which IDENTIFIER', 'Show which tool implementation would be selected'
+    method_option :registry, aliases: :r, desc: 'Path to tool registry', type: :string
+    method_option :platform, desc: 'Platform to check (macos, linux, windows)', type: :string
+    method_option :shell, desc: 'Shell to check (bash, zsh, fish, sh, powershell, cmd)', type: :string
+    def which(identifier)
+      CliCommands::WhichCommand.new(options).run(identifier)
     end
 
-    def default_registry_path
-      # Try multiple approaches to find the registry
-      # 1. Check environment variable
-      env_path = ENV['UKIRYU_REGISTRY']
-      return env_path if env_path && Dir.exist?(env_path)
+    desc 'config [ACTION] [KEY] [VALUE]', 'Manage configuration (list, get, set, unset)'
+    method_option :registry, aliases: :r, desc: 'Path to tool registry', type: :string
+    def config(action = 'list', key = nil, value = nil)
+      CliCommands::ConfigCommand.new(options).run(action, key, value)
+    end
 
-      # 2. Try relative to gem location
-      # From lib/ukiryu/cli.rb, go up to gem root, then to sibling register/
-      gem_root = File.dirname(File.dirname(File.dirname(__FILE__)))
-      registry_path = File.join(gem_root, '..', 'register')
-      if Dir.exist?(registry_path)
-        return File.expand_path(registry_path)
-      end
+    desc 'validate [TOOL]', 'Validate tool profile(s) against schema'
+    method_option :registry, aliases: :r, desc: 'Path to tool registry', type: :string
+    def validate(tool_name = nil)
+      CliCommands::ValidateCommand.new(options).run(tool_name)
+    end
 
-      # 3. Try from current directory (development setup)
-      current = File.expand_path('../register', Dir.pwd)
-      return current if Dir.exist?(current)
+    desc 'extract TOOL', 'Extract tool definition from an installed CLI tool'
+    method_option :output, aliases: :o, desc: 'Output file for extracted definition', type: :string
+    method_option :method, aliases: :m, desc: 'Extraction method (auto, native, help)', type: :string, default: 'auto'
+    method_option :verbose, aliases: :v, desc: 'Enable verbose output', type: :boolean, default: false
+    def extract(tool_name)
+      CliCommands::ExtractCommand.new(options).run(tool_name)
+    end
 
-      # 4. Try from parent directory
-      parent = File.expand_path('../../register', Dir.pwd)
-      return parent if Dir.exist?(parent)
+    private
 
-      nil
+    # Show general information when no specific tool is requested
+    def show_general_info
+      require_relative 'shell'
+      require_relative 'runtime'
+      require_relative 'platform'
+
+      puts "Ukiryu v#{VERSION}"
+      puts ''
+      puts 'System Information:'
+      puts "  Platform: #{Platform.detect}"
+      puts "  Shell: #{Runtime.instance.shell}"
+      puts "  Ruby: #{RUBY_VERSION}"
+      puts ''
+      puts 'Available Shells:'
+      Shell.available_shells.each do |shell|
+        puts "  - #{shell}"
+      end
+      puts ''
+      puts 'Available Commands:'
+      puts '  list                    - List all available tools'
+      puts '  info TOOL               - Show detailed information about a tool'
+      puts '  which IDENTIFIER        - Show which tool implementation would be selected'
+      puts '  commands TOOL           - List all commands available for a tool'
+      puts '  opts TOOL [COMMAND]     - Show options for a tool or specific command'
+      puts '  describe TOOL [COMMAND] - Show comprehensive documentation'
+      puts '  config [ACTION]         - Manage configuration (list, get, set, unset)'
+      puts '  system [shells]         - Show system information (shells, etc.)'
+      puts '  exec ...                - Execute a tool command inline'
+      puts '  run-file ...            - Execute from a YAML file'
+      puts '  version                 - Show Ukiryu version'
+      puts ''
+      puts 'For more information on a specific command:'
+      puts '  ukiryu help COMMAND'
     end
   end
 end

data/lib/ukiryu/cli_commands/base_command.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative '../config'
+
+module Ukiryu
+  module CliCommands
+    # Base class for CLI commands
+    #
+    # Provides shared functionality for all CLI commands including
+    # registry setup, output formatting, and error handling.
+    #
+    # @abstract Subclasses must implement the `run` method
+    class BaseCommand
+      attr_reader :options, :config
+
+      # Initialize a new command
+      #
+      # @param options [Hash] command options from Thor
+      def initialize(options = {})
+        @options = options
+        @config = Ukiryu::Config.instance
+        apply_cli_options_to_config
+      end
+
+      # Execute the command
+      #
+      # Subclasses must implement this method
+      #
+      # @raise [NotImplementedError] if not implemented in subclass
+      def run
+        raise NotImplementedError, "#{self.class} must implement #run"
+      end
+
+      # Setup the registry path
+      #
+      # @param custom_path [String, nil] custom registry path
+      def setup_registry(custom_path = nil)
+        registry_path = custom_path || config.registry || default_registry_path
+        return unless registry_path && Dir.exist?(registry_path)
+
+        Registry.default_registry_path = registry_path
+      end
+
+      # Apply CLI options to the Config instance
+      # CLI options have the highest priority in the configuration chain
+      def apply_cli_options_to_config
+        # Thor option defaults that should not override ENV or programmatic config
+        # Only apply CLI option if it's not the default value
+        cli_mappings = {
+          format: 'yaml', # default format in Thor
+          output: nil,
+          registry: nil,
+          timeout: nil,
+          shell: nil
+        }
+
+        cli_mappings.each do |cli_key, default_value|
+          next unless options.key?(cli_key)
+
+          # Only set CLI option if it's not the default value
+          # This allows ENV and programmatic config to take precedence when user doesn't specify
+          option_value = options[cli_key]
+          should_set = if default_value.nil?
+                         # No default, always set
+                         !option_value.nil? && !option_value.empty?
+                       else
+                         # Only set if different from default (user explicitly specified)
+                         option_value != default_value
+                       end
+
+          config.set_cli_option(cli_key, option_value) if should_set
+        end
+
+        # Handle boolean options from Thor
+        config.set_cli_option(:debug, options[:verbose]) if options.key?(:verbose)
+
+        # Handle dry_run option
+        return unless options.key?(:dry_run)
+
+        config.set_cli_option(:dry_run, options[:dry_run])
+      end
+
+      # Get the default registry path
+      #
+      # @return [String, nil] the default registry path
+      def default_registry_path
+        # Try multiple approaches to find the registry
+        # Note: ENV and Config.registry are already checked by setup_registry
+
+        # 1. Try relative to gem location
+        gem_root = File.dirname(File.dirname(File.dirname(__FILE__)))
+        registry_path = File.join(gem_root, '..', 'register')
+        return File.expand_path(registry_path) if Dir.exist?(registry_path)
+
+        # 2. Try from current directory (development setup)
+        current = File.expand_path('../register', Dir.pwd)
+        return current if Dir.exist?(current)
+
+        # 3. Try from parent directory
+        parent = File.expand_path('../../register', Dir.pwd)
+        return parent if Dir.exist?(parent)
+
+        nil
+      end
+
+      # Convert string keys to symbols
+      #
+      # @param hash [Hash] hash with string keys
+      # @return [Hash] hash with symbol keys
+      def stringify_keys(hash)
+        hash.transform_keys(&:to_sym)
+      end
+
+      protected
+
+      # Say output (Thor compatibility)
+      #
+      # Respects the use_color configuration option and NO_COLOR environment variable.
+      #
+      # @param message [String] the message
+      # @param color [Symbol] the color
+      def say(message, color = nil)
+        # Check if colors should be disabled
+        # Config handles both use_color setting and NO_COLOR environment variable
+        colors_disabled = config.colors_disabled?
+
+        if color && !colors_disabled
+          # Use ANSI color codes
+          colors = {
+            black: 30,
+            red: 31,
+            green: 32,
+            yellow: 33,
+            blue: 34,
+            magenta: 35,
+            cyan: 36,
+            white: 37,
+            dim: 2 # bright/black for dim
+          }
+          code = colors[color] || 37
+          puts "\e[#{code}m#{message}\e[0m"
+        else
+          puts message
+        end
+      end
+
+      # Exit with error message
+      #
+      # @param message [String] the error message
+      def error!(message)
+        raise Thor::Error, message
+      end
+    end
+  end
+end