ukiryu 0.1.0 → 0.1.1

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

@@ -0,0 +1,105 @@
+# 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
+
+          tool = Tool.get(tool_name)
+          tool_commands = tool.commands
+
+          error! "No commands defined for #{tool_name}" unless tool_commands
+
+          # Find the command
+          cmds = if command_name
+                   cmd = tool_commands[command_name.to_sym] || tool_commands[command_name]
+                   cmd ? [cmd] : []
+                 else
+                   tool_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.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
+end

data/lib/ukiryu/cli_commands/response_formatter.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module Ukiryu
+  module CliCommands
+    # Response formatting module for CLI commands
+    #
+    # Provides reusable formatting methods for execution responses
+    # in multiple formats (YAML, JSON, table, raw).
+    module ResponseFormatter
+      # Supported output formats
+      OUTPUT_FORMATS = %i[yaml json table raw].freeze
+
+      # Output response in specified format
+      #
+      # @param response [Models::SuccessResponse, Models::ErrorResponse] the response to format
+      # @param format [Symbol] the output format (:yaml, :json, :table, or :raw)
+      # @param output_file [String, nil] optional file path to write output
+      # @param config [Object] the CLI config object
+      # @return [void]
+      def output_response(response, format, output_file, config)
+        if format == :raw
+          output_raw_response(response, output_file)
+        else
+          output_string = case format
+                          when :yaml
+                            format_yaml_response(response, config)
+                          when :json
+                            format_json_response(response)
+                          when :table, :human
+                            format_table_response(response, config)
+                          else
+                            response.to_yaml
+                          end
+
+          if output_file
+            File.write(output_file, output_string)
+            say "Response written to: #{output_file}", :green
+          else
+            say output_string
+          end
+        end
+      end
+
+      # Show dry run output
+      #
+      # @param request [Hash] the execution request
+      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
+
+      private
+
+      # Format response as colored YAML
+      #
+      # @param response [Models::SuccessResponse, Models::ErrorResponse] the response
+      # @param config [Object] the CLI config object
+      # @return [String] formatted YAML
+      def format_yaml_response(response, config)
+        yaml_content = response.to_yaml
+
+        # Determine if we should use colors:
+        # - Config.use_color can be true, false, or nil (auto-detect)
+        # - Auto-detect: only use colors if TTY and colors are not disabled via config/NO_COLOR
+        use_colors = if config.use_color.nil?
+                       $stdout.tty? && !config.colors_disabled?
+                     else
+                       config.use_color
+                     end
+
+        return yaml_content unless use_colors
+
+        begin
+          require 'paint'
+          paint = Paint.method(:[])
+          # Add color coding to YAML output (no explicit newlines, let say handle it)
+          yaml_content.each_line.map do |line|
+            case line
+            when /^status:/
+              paint[line, :cyan, :bright]
+            when /^exit_code:/
+              paint[line, :yellow]
+            when /^  executable:/
+              paint[line, :green]
+            when /^  full_command:/
+              paint[line, :blue, :bright]
+            when /^stdout:/
+              line  # No color for stdout - let terminal decide
+            when /^stderr:/
+              paint[line, :red]
+            when /^  started_at:|^  finished_at:/
+              line  # No color for timestamps - let terminal decide
+            when /^  duration_seconds:|^  formatted_duration:/
+              paint[line, :magenta]
+            else
+              line
+            end
+          end.join
+        rescue LoadError
+          yaml_content
+        end
+      end
+
+      # Format response as JSON
+      #
+      # @param response [Models::SuccessResponse, Models::ErrorResponse] the response
+      # @return [String] formatted JSON
+      def format_json_response(response)
+        response.to_json(pretty: true)
+      end
+
+      # Output response in raw format (for pipe composition)
+      #
+      # In raw mode:
+      # - stdout from the command is written directly to stdout
+      # - stderr from the command is written directly to stderr
+      # - No wrapping in YAML/JSON structures
+      # - Enables clean pipe composition: echo "test" | ukiryu exec jq --raw filter="." | other_tool
+      #
+      # @param response [Models::SuccessResponse, Models::ErrorResponse] the response
+      # @param output_file [String, nil] optional file path to write output
+      # @return [void]
+      def output_raw_response(response, output_file)
+        if response.is_a?(Models::SuccessResponse)
+          # Write stdout to stdout (without say() to avoid extra newlines)
+          $stdout.write(response.output.stdout)
+          $stdout.flush if response.output.stdout.empty? || response.output.stdout.end_with?("\n")
+
+          # Write stderr to stderr
+          unless response.output.stderr.empty?
+            $stderr.write(response.output.stderr)
+            $stderr.flush
+          end
+
+          # Write to file if specified
+          File.write(output_file, response.output.stdout) if output_file
+        else
+          # Error response: write error message to stderr
+          $stderr.write("#{response.error}\n")
+          $stderr.flush
+        end
+      end
+
+      # Format response as human-readable table
+      #
+      # @param response [Models::SuccessResponse, Models::ErrorResponse] the response
+      # @param config [Object] the CLI config object
+      # @return [String] formatted table
+      def format_table_response(response, config)
+        if response.is_a?(Models::SuccessResponse)
+          format_success_table(response, config)
+        else
+          format_error_table(response, config)
+        end
+      end
+
+      # Format success response as table
+      #
+      # @param response [Models::SuccessResponse] the success response
+      # @param config [Object] the CLI config object
+      # @return [String] formatted success table
+      def format_success_table(response, config)
+        return format_plain_success_table(response, config) unless defined?(Paint)
+
+        begin
+          require 'paint'
+          paint = Paint.method(:[])
+          success_icon = paint['✓', :green]
+
+          output = []
+          output << "#{success_icon} #{paint['Command completed successfully', :green, :bright]}\n"
+          output << "#{paint['Exit code:', :white]} #{response.exit_code}\n"
+          output << "#{paint['Duration:', :white]} #{response.metadata.formatted_duration}\n"
+          output << "\n#{paint['Request:', :cyan, :bright]} #{format_request_summary(response.request)}\n"
+          output << "\n#{paint['Command:', :cyan, :bright]} #{response.command.full_command}\n"
+
+          unless response.output.stdout.empty?
+            first_line = response.output.stdout.split("\n").first
+            output << "\n#{paint['Output:', :white]} #{first_line}\n"
+          end
+
+          output << "\n#{paint['Errors:', :red]} #{response.output.stderr}\n" unless response.output.stderr.empty?
+
+          output.join("\n")
+        rescue LoadError
+          format_plain_success_table(response, config)
+        end
+      end
+
+      # Format request summary for table display
+      #
+      # @param request [Models::Request] the request object
+      # @return [String] formatted request summary
+      def format_request_summary(request)
+        parts = []
+        parts << request.options.map { |opt| "#{opt.name}=#{opt.value}" }.join(' ') unless request.options.empty?
+        parts << request.flags.map { |flag| "--#{flag}" }.join(' ') unless request.flags.empty?
+        parts << request.positional.map(&:value).join(' ') unless request.positional.empty?
+        parts.join(' ')
+      end
+
+      # Format success response without Paint
+      #
+      # @param response [Models::SuccessResponse] the success response
+      # @param _config [Object] the CLI config object (unused)
+      # @return [String] plain text success table
+      def format_plain_success_table(response, _config)
+        "✓ Command completed successfully\n" \
+        "Exit code: #{response.exit_code}\n" \
+        "Duration: #{response.metadata.formatted_duration}\n" \
+        "\nRequest: #{format_request_summary(response.request)}\n" \
+        "\nCommand: #{response.command.full_command}\n"
+      end
+
+      # Format error response as table
+      #
+      # @param response [Models::ErrorResponse] the error response
+      # @param _config [Object] the CLI config object (unused)
+      # @return [String] formatted error table
+      def format_error_table(response, _config)
+        return "✗ Command failed: #{response.error}\n" unless defined?(Paint)
+
+        begin
+          require 'paint'
+          paint = Paint.method(:[])
+          error_icon = paint['✗', :red]
+          "#{error_icon} #{paint['Command failed:', :red, :bright]} #{response.error}\n"
+        rescue LoadError
+          "✗ Command failed: #{response.error}\n"
+        end
+      end
+    end
+  end
+end