ukiryu 0.1.0 → 0.1.1

data/lib/ukiryu/cli_commands/commands_command.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+require_relative '../tool'
+
+module Ukiryu
+  module CliCommands
+    # List all commands available for a tool
+    class CommandsCommand < BaseCommand
+      # Execute the commands 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
+
+        tool_commands = tool.commands
+        error! "No commands defined for #{tool_name}" unless tool_commands
+
+        say "Commands for #{tool_name}:", :cyan
+
+        # Group commands by their parent (belongs_to) for hierarchical tools
+        grouped = group_commands_by_parent(tool_commands)
+
+        if grouped.key?(nil) && grouped.size == 1
+          # Flat structure - no routing/hierarchy
+          grouped[nil].each do |cmd|
+            display_command(cmd)
+          end
+        else
+          # Hierarchical structure - show routing groups
+          display_hierarchical_commands(tool, grouped)
+        end
+      end
+
+      private
+
+      # Group commands by their parent (belongs_to)
+      #
+      # @param commands [Array] list of commands
+      # @return [Hash] grouped commands with nil key for top-level
+      #
+      def group_commands_by_parent(commands)
+        grouped = Hash.new { |h, k| h[k] = [] }
+
+        commands.each do |cmd|
+          parent = cmd.belongs_to
+          grouped[parent] << cmd
+        end
+
+        grouped
+      end
+
+      # Display a single command
+      #
+      # @param cmd [CommandDefinition] the command to display
+      #
+      def display_command(cmd)
+        cmd_name = cmd.name || 'unnamed'
+        description = cmd.description || 'No description'
+        say "  #{cmd_name.to_s.ljust(20)} #{description}", :white
+
+        # Show usage if available
+        say "    Usage: #{cmd.usage}", :dim if cmd.usage
+
+        # Show subcommand if exists
+        if cmd.subcommand
+          subcommand_info = cmd.subcommand.nil? ? '(none)' : cmd.subcommand
+          say "    Subcommand: #{subcommand_info}", :dim
+        end
+
+        # Show cli_flag if this is a flag-based action
+        if cmd.flag_action?
+          say "    Action flag: #{cmd.cli_flag}", :dim
+        end
+      end
+
+      # Display hierarchical commands with routing information
+      #
+      # @param tool [Tool] the tool instance
+      # @param grouped [Hash] grouped commands
+      #
+      def display_hierarchical_commands(tool, grouped)
+        # Show routing table first
+        if tool.routing?
+          say "  Routing table:", :dim
+          tool.routing.keys.each do |key|
+            target = tool.routing.resolve(key)
+            say "    #{key} => #{target}", :dim
+          end
+          say '', :clear
+        end
+
+        # Show top-level commands (no belongs_to)
+        if grouped.key?(nil) && !grouped[nil].empty?
+          say "  Top-level commands:", :cyan
+          grouped[nil].each do |cmd|
+            display_command(cmd)
+          end
+          say '', :clear
+        end
+
+        # Show commands grouped by parent
+        grouped.each do |parent, cmds|
+          next if parent.nil?
+
+          target = tool.routing&.resolve(parent) || parent
+          say "  #{parent} commands (route to: #{target}):", :cyan
+          cmds.each do |cmd|
+            display_command(cmd)
+          end
+          say '', :clear
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+require_relative '../tool'
+
+module Ukiryu
+  module CliCommands
+      # List all commands available for a tool
+    class CommandsCommand < BaseCommand
+        # Execute the commands command
+        #
+        # @param tool_name [String] the tool name
+      def run(tool_name)
+          setup_registry
+
+          tool = Tool.get(tool_name)
+          tool_commands = tool.commands
+
+          error! "No commands defined for #{tool_name}" unless tool_commands
+
+          say "Commands for #{tool_name}:", :cyan
+          tool_commands.each do |cmd_name, cmd|
+            cmd_name ||= 'unnamed'
+            description = cmd.description || 'No description'
+            say "  #{cmd_name.to_s.ljust(20)} #{description}", :white
+
+            # Show usage if available
+            say "    Usage: #{cmd.usage}", :dim if cmd.usage
+
+            # Show subcommand if exists
+            if cmd.subcommand
+              subcommand_info = cmd.subcommand.nil? ? '(none)' : cmd.subcommand
+              say "    Subcommand: #{subcommand_info}", :dim
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ukiryu/cli_commands/config_command.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+require_relative '../config'
+require 'yaml'
+require 'fileutils'
+
+module Ukiryu
+  module CliCommands
+    # Configuration management command
+    class ConfigCommand < BaseCommand
+      CONFIG_DIR = File.expand_path('~/.ukiryu')
+      CONFIG_FILE = File.join(CONFIG_DIR, 'config.yml')
+
+      # Execute the config command
+      #
+      # @param action [String] the action (list, get, set, unset)
+      # @param key [String, nil] the config key
+      # @param value [String, nil] the config value
+      def run(action = 'list', key = nil, value = nil)
+        setup_registry
+
+        case action
+        when 'list'
+          action_list
+        when 'get'
+          action_get(key)
+        when 'set'
+          action_set(key, value)
+        when 'unset'
+          action_unset(key)
+        else
+          error! "Unknown action: #{action}\nValid actions: list, get, set, unset"
+        end
+      end
+
+      private
+
+      # List all configuration
+      def action_list
+        say 'Current configuration:', :cyan
+        say '', :clear
+
+        config_data = {
+          'Registry' => config.registry || '(not set)',
+          'Timeout' => format_config_value(config.timeout, '(no timeout)'),
+          'Debug' => format_config_value(config.debug),
+          'Dry run' => format_config_value(config.dry_run),
+          'Metrics' => format_config_value(config.metrics),
+          'Shell' => format_config_value(config.shell, '(auto-detect)'),
+          'Format' => format_config_value(config.format),
+          'Output' => format_config_value(config.output, '(stdout)'),
+          'Search paths' => format_config_value(config.search_paths, '(not set)'),
+          'Use color' => format_config_value(config.use_color, '(auto-detect)')
+        }
+
+        config_data.each do |k, v|
+          value_str = v.is_a?(String) ? "'#{v}'" : v.to_s
+          say "  #{k.ljust(20)}: #{value_str}", :white
+        end
+
+        # Show persistent config if exists
+        say '', :clear
+        if File.exist?(CONFIG_FILE)
+          say 'Persistent configuration:', :cyan
+          say "  File: #{CONFIG_FILE}", :dim
+
+          persistent = load_persistent_config
+          if persistent && !persistent.empty?
+            persistent.each do |k, v|
+              say "  #{k}: #{v}", :dim
+            end
+          else
+            say '  (empty)', :dim
+          end
+        else
+          say 'No persistent configuration file found.', :dim
+          say "  Config would be saved to: #{CONFIG_FILE}", :dim
+        end
+
+        # Show environment variables
+        say '', :clear
+        say 'Environment variables:', :cyan
+        env_vars = {
+          'UKIRYU_REGISTRY' => ENV['UKIRYU_REGISTRY'],
+          'UKIRYU_TIMEOUT' => ENV['UKIRYU_TIMEOUT'],
+          'UKIRYU_DEBUG' => ENV['UKIRYU_DEBUG'],
+          'UKIRYU_DRY_RUN' => ENV['UKIRYU_DRY_RUN'],
+          'UKIRYU_METRICS' => ENV['UKIRYU_METRICS'],
+          'UKIRYU_SHELL' => ENV['UKIRYU_SHELL'],
+          'UKIRYU_FORMAT' => ENV['UKIRYU_FORMAT'],
+          'UKIRYU_OUTPUT' => ENV['UKIRYU_OUTPUT'],
+          'UKIRYU_SEARCH_PATHS' => ENV['UKIRYU_SEARCH_PATHS'],
+          'UKIRYU_USE_COLOR' => ENV['UKIRYU_USE_COLOR']
+        }
+
+        has_env = false
+        env_vars.each do |k, v|
+          if v
+            has_env = true
+            say "  #{k.ljust(25)}: #{v}", :white
+          end
+        end
+        say '  (none set)', :dim unless has_env
+      end
+
+      # Get a configuration value
+      #
+      # @param key [String] the config key
+      def action_get(key)
+        normalized_key = normalize_key(key)
+
+        value = case normalized_key
+                when :registry then config.registry
+                when :timeout then config.timeout
+                when :debug then config.debug
+                when :dry_run then config.dry_run
+                when :metrics then config.metrics
+                when :shell then config.shell
+                when :format then config.format
+                when :output then config.output
+                when :search_paths then config.search_paths
+                when :use_color then config.use_color
+                else
+                  error! "Unknown config key: #{key}\nValid keys: registry, timeout, debug, dry_run, metrics, shell, format, output, search_paths, use_color"
+                end
+
+        say "#{key}: #{format_config_value(value, '(not set)')}", :white
+      end
+
+      # Set a configuration value (persisted to file)
+      #
+      # @param key [String] the config key
+      # @param value [String] the config value
+      def action_set(key, value)
+        error! 'Usage: ukiryu config set <key> <value>' unless key && value
+
+        normalized_key = normalize_key(key)
+        parsed_value = parse_value(normalized_key, value)
+
+        # Save to persistent config
+        ensure_config_dir
+        persistent = load_persistent_config || {}
+        persistent[key] = value
+        save_persistent_config(persistent)
+
+        # Also set in current config
+        set_config_value(normalized_key, parsed_value)
+
+        say "Set #{key} = #{value}", :green
+        say "Saved to: #{CONFIG_FILE}", :dim
+      end
+
+      # Unset a configuration value
+      #
+      # @param key [String] the config key
+      def action_unset(key)
+        error! 'Usage: ukiryu config unset <key>' unless key
+
+        persistent = load_persistent_config
+        error! "Key not set in persistent config: #{key}" unless persistent&.key?(key)
+
+        persistent.delete(key)
+        save_persistent_config(persistent)
+
+        say "Unset #{key}", :green
+        say "Updated: #{CONFIG_FILE}", :dim
+      end
+
+      # Normalize key to symbol
+      #
+      # @param key [String] the key
+      # @return [Symbol] normalized key
+      def normalize_key(key)
+        key.to_s.downcase.to_sym
+      end
+
+      # Parse value based on key type
+      #
+      # @param key [Symbol] the config key
+      # @param value [String] the string value
+      # @return [Object] parsed value
+      def parse_value(key, value)
+        case key
+        when :timeout
+          value.to_i
+        when :debug, :dry_run, :metrics, :use_color
+          %w[true yes 1].include?(value.downcase)
+        when :format
+          value.to_sym
+        else
+          value
+        end
+      end
+
+      # Set config value
+      #
+      # @param key [Symbol] the config key
+      # @param value [Object] the value
+      def set_config_value(key, value)
+        case key
+        when :timeout then config.timeout = value
+        when :debug then config.debug = value
+        when :dry_run then config.dry_run = value
+        when :metrics then config.metrics = value
+        when :shell then config.shell = value
+        when :format then config.format = value
+        when :output then config.output = value
+        when :registry then config.registry = value
+        when :search_paths then config.search_paths = value
+        when :use_color then config.use_color = value
+        end
+      end
+
+      # Format config value for display
+      #
+      # @param value [Object] the value
+      # @param default [String] default string for nil
+      # @return [String] formatted value
+      def format_config_value(value, default = '(nil)')
+        value.nil? ? default : value
+      end
+
+      # Ensure config directory exists
+      def ensure_config_dir
+        FileUtils.mkdir_p(CONFIG_DIR) unless Dir.exist?(CONFIG_DIR)
+      end
+
+      # Load persistent config from file
+      #
+      # @return [Hash, nil] the persistent config or nil
+      def load_persistent_config
+        return nil unless File.exist?(CONFIG_FILE)
+
+        YAML.load_file(CONFIG_FILE, permitted_classes: [Symbol])
+      rescue StandardError => e
+        say "Warning: Failed to load config file: #{e.message}", :red
+        nil
+      end
+
+      # Save persistent config to file
+      #
+      # @param data [Hash] the config data
+      def save_persistent_config(data)
+        File.write(CONFIG_FILE, data.to_yaml)
+      end
+    end
+  end
+end