ukiryu 0.1.0 → 0.1.1

data/lib/ukiryu/executor.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-require "open3"
-require "timeout"
+require 'open3'
+require 'timeout'
+require_relative 'execution'
+require_relative 'shell'
 
 module Ukiryu
   # Command execution with platform-specific methods
@@ -22,7 +24,10 @@ module Ukiryu
       # @option options [Hash] :env environment variables
       # @option options [String] :cwd working directory
       # @option options [Symbol] :shell shell to use (default: auto-detect)
-      # @return [Result] execution result with composed OOP classes
+      # @option options [String, IO] :stdin stdin input data (string or IO object)
+      # @option options [String] :tool_name tool name for exit code lookups
+      # @option options [String] :command_name command name for exit code lookups
+      # @return [Execution::Result] execution result with composed OOP classes
       # @raise [TimeoutError] if command times out
       # @raise [ExecutionError] if command fails
       def execute(executable, args = [], options = {})
@@ -38,31 +43,38 @@ module Ukiryu
         # Execute with timeout
         timeout = options[:timeout] || 90
         cwd = options[:cwd]
+        stdin = options[:stdin]
 
         started_at = Time.now
         begin
-          result = execute_with_timeout(command, env, timeout, cwd)
+          result = if stdin
+                     execute_with_stdin(command, env, timeout, cwd, stdin)
+                   else
+                     execute_with_timeout(command, env, timeout, cwd)
+                   end
         rescue Timeout::Error
-          finished_at = Time.now
+          Time.now
           raise TimeoutError, "Command timed out after #{timeout} seconds: #{executable}"
         end
         finished_at = Time.now
 
-        # Create OOP result components
-        command_info = CommandInfo.new(
+        # Create OOP result components using Execution namespace
+        command_info = Execution::CommandInfo.new(
           executable: executable,
           arguments: args,
           full_command: command,
-          shell: shell_name
+          shell: shell_name,
+          tool_name: options[:tool_name],
+          command_name: options[:command_name]
         )
 
-        output = Output.new(
+        output = Execution::Output.new(
           stdout: result[:stdout],
           stderr: result[:stderr],
           exit_status: result[:status]
         )
 
-        metadata = ExecutionMetadata.new(
+        metadata = Execution::ExecutionMetadata.new(
           started_at: started_at,
           finished_at: finished_at,
           timeout: timeout
@@ -70,10 +82,11 @@ module Ukiryu
 
         # Check exit status
         if result[:status] != 0 && !options[:allow_failure]
-          raise ExecutionError, format_error(executable, command, result)
+          raise ExecutionError,
+                format_error(executable, command, result)
         end
 
-        Result.new(
+        Execution::Result.new(
           command_info: command_info,
           output: output,
           metadata: metadata
@@ -88,7 +101,7 @@ module Ukiryu
       # @return [String, nil] the full path to the executable, or nil if not found
       def find_executable(command, options = {})
         # Try with PATHEXT extensions (Windows executables)
-        exts = ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [""]
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
 
         search_paths = Platform.executable_search_paths
         search_paths.concat(options[:additional_paths]) if options[:additional_paths]
@@ -168,6 +181,56 @@ module Ukiryu
         end
       end
 
+      # Execute command with stdin input
+      #
+      # @param command [String] the command to execute
+      # @param env [Hash] environment variables
+      # @param timeout [Integer] timeout in seconds
+      # @param cwd [String, nil] working directory (nil for current directory)
+      # @param stdin_data [String, IO] stdin input data
+      # @return [Hash] execution result
+      def execute_with_stdin(command, env, timeout, cwd, stdin_data)
+        Timeout.timeout(timeout) do
+          execution = lambda do
+            Open3.popen3(env, command) do |stdin, stdout, stderr, wait_thr|
+              # Write stdin data
+              begin
+                if stdin_data.is_a?(IO)
+                  IO.copy_stream(stdin_data, stdin)
+                elsif stdin_data.is_a?(String)
+                  stdin.write(stdin_data)
+                end
+              rescue Errno::EPIPE
+                # Process closed stdin early (e.g., 'head' command)
+              ensure
+                stdin.close
+              end
+
+              # Read output
+              out = stdout.read
+              err = stderr.read
+
+              # Wait for process to complete
+              status = wait_thr.value
+
+              {
+                status: extract_status(status),
+                stdout: out,
+                stderr: err
+              }
+            end
+          end
+
+          if cwd
+            Dir.chdir(cwd) do
+              execution.call
+            end
+          else
+            execution.call
+          end
+        end
+      end
+
       # Extract exit status from Process::Status
       #
       # @param status [Process::Status] the process status
@@ -232,485 +295,5 @@ module Ukiryu
         ERROR
       end
     end
-
-    # Execution command information
-    #
-    # Encapsulates details about the executed command
-    class CommandInfo
-      attr_reader :executable, :arguments, :full_command, :shell
-
-      def initialize(executable:, arguments:, full_command:, shell: nil)
-        @executable = executable
-        @arguments = arguments
-        @full_command = full_command
-        @shell = shell
-      end
-
-      # Get the executable name only
-      #
-      # @return [String] executable name
-      def executable_name
-        File.basename(@executable)
-      end
-
-      # Get argument count
-      #
-      # @return [Integer] number of arguments
-      def argument_count
-        @arguments.count
-      end
-
-      # String representation
-      #
-      # @return [String] command string
-      def to_s
-        @full_command
-      end
-
-      # Inspect
-      #
-      # @return [String] inspection string
-      def inspect
-        "#<Ukiryu::Executor::CommandInfo exe=#{executable_name.inspect} args=#{argument_count}>"
-      end
-
-      # Convert to hash
-      #
-      # @return [Hash] command info as hash
-      def to_h
-        {
-          executable: @executable,
-          executable_name: executable_name,
-          arguments: @arguments,
-          full_command: @full_command,
-          shell: @shell
-        }
-      end
-    end
-
-    # Captured output from command execution
-    #
-    # Provides typed access to stdout and stderr with parsing utilities
-    class Output
-      attr_reader :raw_stdout, :raw_stderr, :exit_status
-
-      def initialize(stdout:, stderr:, exit_status:)
-        @raw_stdout = stdout
-        @raw_stderr = stderr
-        @exit_status = exit_status
-      end
-
-      # Get stdout as a string (stripped)
-      #
-      # @return [String] stripped stdout
-      def stdout
-        @raw_stdout.strip
-      end
-
-      # Get stderr as a string (stripped)
-      #
-      # @return [String] stripped stderr
-      def stderr
-        @raw_stderr.strip
-      end
-
-      # Get stdout lines as an array
-      #
-      # @return [Array<String>] stdout split by lines
-      def stdout_lines
-        @raw_stdout.split("\n")
-      end
-
-      # Get stderr lines as an array
-      #
-      # @return [Array<String>] stderr split by lines
-      def stderr_lines
-        @raw_stderr.split("\n")
-      end
-
-      # Check if stdout contains a pattern
-      #
-      # @param pattern [String, Regexp] pattern to search for
-      # @return [Boolean] true if pattern is found
-      def stdout_contains?(pattern)
-        if pattern.is_a?(Regexp)
-          @raw_stdout.match?(pattern)
-        else
-          @raw_stdout.include?(pattern.to_s)
-        end
-      end
-
-      # Check if stderr contains a pattern
-      #
-      # @param pattern [String, Regexp] pattern to search for
-      # @return [Boolean] true if pattern is found
-      def stderr_contains?(pattern)
-        if pattern.is_a?(Regexp)
-          @raw_stderr.match?(pattern)
-        else
-          @raw_stderr.include?(pattern.to_s)
-        end
-      end
-
-      # Check if stdout is empty
-      #
-      # @return [Boolean] true if stdout is empty
-      def stdout_empty?
-        @raw_stdout.strip.empty?
-      end
-
-      # Check if stderr is empty
-      #
-      # @return [Boolean] true if stderr is empty
-      def stderr_empty?
-        @raw_stderr.strip.empty?
-      end
-
-      # Get stdout length
-      #
-      # @return [Integer] byte length of stdout
-      def stdout_length
-        @raw_stdout.length
-      end
-
-      # Get stderr length
-      #
-      # @return [Integer] byte length of stderr
-      def stderr_length
-        @raw_stderr.length
-      end
-
-      # Check if command succeeded
-      #
-      # @return [Boolean] true if exit status is 0
-      def success?
-        @exit_status == 0
-      end
-
-      # Check if command failed
-      #
-      # @return [Boolean] true if exit status is non-zero
-      def failure?
-        @exit_status != 0
-      end
-
-      # Convert to hash
-      #
-      # @return [Hash] output as hash
-      def to_h
-        {
-          stdout: @raw_stdout,
-          stderr: @raw_stderr,
-          exit_status: @exit_status,
-          success: success?,
-          stdout_lines: stdout_lines,
-          stderr_lines: stderr_lines
-        }
-      end
-
-      # String representation
-      #
-      # @return [String] summary string
-      def to_s
-        if success?
-          "Success (exit: #{@exit_status}, stdout: #{stdout_length} bytes, stderr: #{stderr_length} bytes)"
-        else
-          "Failed (exit: #{@exit_status}, stdout: #{stdout_length} bytes, stderr: #{stderr_length} bytes)"
-        end
-      end
-
-      # Inspect
-      #
-      # @return [String] inspection string
-      def inspect
-        "#<Ukiryu::Executor::Output exit=#{@exit_status} success=#{success?}>"
-      end
-    end
-
-    # Execution metadata
-    #
-    # Provides timing and execution environment information
-    class ExecutionMetadata
-      attr_reader :started_at, :finished_at, :duration, :timeout
-
-      def initialize(started_at:, finished_at:, timeout: nil)
-        @started_at = started_at
-        @finished_at = finished_at
-        @timeout = timeout
-        @duration = calculate_duration
-      end
-
-      # Calculate duration from start and finish times
-      #
-      # @return [Float, nil] duration in seconds
-      def calculate_duration
-        return nil unless @started_at && @finished_at
-
-        @finished_at - @started_at
-      end
-
-      # Get execution duration in seconds
-      #
-      # @return [Float, nil] duration in seconds
-      def duration_seconds
-        @duration
-      end
-
-      # Get execution duration in milliseconds
-      #
-      # @return [Float, nil] duration in milliseconds
-      def duration_milliseconds
-        @duration ? @duration * 1000 : nil
-      end
-
-      # Check if execution timed out
-      #
-      # @return [Boolean] true if timeout was set and exceeded
-      def timed_out?
-        return false unless @timeout && @duration
-
-        @duration > @timeout
-      end
-
-      # Format duration for display
-      #
-      # @return [String] formatted duration
-      def formatted_duration
-        return "N/A" unless @duration
-
-        if @duration < 1
-          "#{(@duration * 1000).round(2)}ms"
-        elsif @duration < 60
-          "#{@duration.round(3)}s"
-        else
-          minutes = @duration / 60
-          seconds = @duration % 60
-          "#{minutes.to_i}m#{seconds.round(1)}s"
-        end
-      end
-
-      # Convert to hash
-      #
-      # @return [Hash] metadata as hash
-      def to_h
-        {
-          started_at: @started_at,
-          finished_at: @finished_at,
-          duration: @duration,
-          duration_seconds: @duration,
-          duration_milliseconds: duration_milliseconds,
-          timeout: @timeout,
-          timed_out: timed_out?
-        }
-      end
-
-      # String representation
-      #
-      # @return [String] formatted string
-      def to_s
-        "duration: #{formatted_duration}"
-      end
-
-      # Inspect
-      #
-      # @return [String] inspection string
-      def inspect
-        "#<Ukiryu::Executor::ExecutionMetadata duration=#{formatted_duration}>"
-      end
-    end
-
-    # Result class for command execution
-    #
-    # Provides a rich, object-oriented interface to command execution results.
-    # Composes CommandInfo, Output, and ExecutionMetadata for a fully OOP design.
-    class Result
-      attr_reader :command_info, :output, :metadata
-
-      # Initialize a new result
-      #
-      # @param command_info [CommandInfo] the command execution info
-      # @param output [Output] the captured output
-      # @param metadata [ExecutionMetadata] execution metadata
-      def initialize(command_info:, output:, metadata:)
-        @command_info = command_info
-        @output = output
-        @metadata = metadata
-      end
-
-      # Get the full command string
-      #
-      # @return [String] executed command
-      def command
-        @command_info.full_command
-      end
-
-      # Get the executable
-      #
-      # @return [String] executable path
-      def executable
-        @command_info.executable
-      end
-
-      # Get the executable name only
-      #
-      # @return [String] executable name
-      def executable_name
-        @command_info.executable_name
-      end
-
-      # Get raw stdout
-      #
-      # @return [String] raw stdout
-      def stdout
-        @output.raw_stdout
-      end
-
-      # Get raw stderr
-      #
-      # @return [String] raw stderr
-      def stderr
-        @output.raw_stderr
-      end
-
-      # Get exit status code
-      #
-      # @return [Integer] exit status
-      def status
-        @output.exit_status
-      end
-      alias exit_code status
-
-      # Get the exit code (alias for status)
-      #
-      # @return [Integer] exit status
-      def exit_status
-        @output.exit_status
-      end
-
-      # Get start time
-      #
-      # @return [Time] when command started
-      def started_at
-        @metadata.started_at
-      end
-
-      # Get finish time
-      #
-      # @return [Time] when command finished
-      def finished_at
-        @metadata.finished_at
-      end
-
-      # Get execution duration
-      #
-      # @return [Float, nil] duration in seconds
-      def duration
-        @metadata.duration
-      end
-
-      # Get execution duration (alias)
-      #
-      # @return [Float, nil] duration in seconds
-      def execution_time
-        @metadata.duration_seconds
-      end
-
-      # Check if the command succeeded
-      #
-      # @return [Boolean]
-      def success?
-        @output.success?
-      end
-
-      # Check if the command failed
-      #
-      # @return [Boolean]
-      def failure?
-        @output.failure?
-      end
-
-      # Get stdout as a stripped string
-      #
-      # @return [String] stripped stdout
-      def output
-        @output.stdout
-      end
-
-      # Get stderr as a stripped string
-      #
-      # @return [String] stripped stderr
-      def error_output
-        @output.stderr
-      end
-
-      # Get stdout lines
-      #
-      # @return [Array<String>] stdout split by lines
-      def stdout_lines
-        @output.stdout_lines
-      end
-
-      # Get stderr lines
-      #
-      # @return [Array<String>] stderr split by lines
-      def stderr_lines
-        @output.stderr_lines
-      end
-
-      # Check if stdout contains a pattern
-      #
-      # @param pattern [String, Regexp] pattern to search for
-      # @return [Boolean] true if pattern is found
-      def stdout_contains?(pattern)
-        @output.stdout_contains?(pattern)
-      end
-
-      # Check if stderr contains a pattern
-      #
-      # @param pattern [String, Regexp] pattern to search for
-      # @return [Boolean] true if pattern is found
-      def stderr_contains?(pattern)
-        @output.stderr_contains?(pattern)
-      end
-
-      # Get a hash representation of the result
-      #
-      # @return [Hash] result data as a hash
-      def to_h
-        {
-          command: @command_info.to_h,
-          output: @output.to_h,
-          metadata: @metadata.to_h,
-          success: success?,
-          status: status
-        }
-      end
-
-      # Get a JSON representation of the result
-      #
-      # @return [String] result data as JSON
-      def to_json(*args)
-        require 'json'
-        to_h.to_json(*args)
-      end
-
-      # String representation of the result
-      #
-      # @return [String] summary of the result
-      def to_s
-        if success?
-          "Success (#{@command_info.executable_name}, status: #{status}, duration: #{@metadata.formatted_duration})"
-        else
-          "Failed (#{@command_info.executable_name}, status: #{status}, duration: #{@metadata.formatted_duration})"
-        end
-      end
-
-      # Inspect the result (for debugging)
-      #
-      # @return [String] detailed inspection string
-      def inspect
-        "#<Ukiryu::Executor::Result exe=#{@command_info.executable_name.inspect} status=#{status} duration=#{@metadata.formatted_duration}>"
-      end
-    end
   end
 end

data/lib/ukiryu/extractors/base_extractor.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Ukiryu
+  module Extractors
+    # Base class for definition extraction strategies
+    #
+    # Each extraction strategy implements a different approach to
+    # extracting tool definitions from CLI tools.
+    #
+    # @abstract Subclasses must implement the `extract` method
+    class BaseExtractor
+      # Initialize the extractor
+      #
+      # @param tool_name [String, Symbol] the tool name
+      # @param options [Hash] extraction options
+      def initialize(tool_name, options = {})
+        @tool_name = tool_name
+        @options = options
+      end
+
+      # Extract definition from the tool
+      #
+      # Subclasses must implement this method
+      #
+      # @return [String, nil] the YAML definition or nil if extraction failed
+      # @raise [NotImplementedError] if not implemented in subclass
+      def extract
+        raise NotImplementedError, "#{self.class} must implement #extract"
+      end
+
+      # Check if this extractor can extract from the tool
+      #
+      # @return [Boolean] true if extraction is possible
+      def available?
+        raise NotImplementedError, "#{self.class} must implement #available?"
+      end
+
+      private
+
+      # Execute a command and capture output
+      #
+      # @param command [Array<String>] the command to execute
+      # @return [Hash] result with :stdout, :stderr, :exit_status keys
+      def execute_command(command)
+        require 'open3'
+
+        stdout, stderr, status = Open3.capture3(*command)
+        {
+          stdout: stdout,
+          stderr: stderr,
+          exit_status: status.exitstatus
+        }
+      rescue Errno::ENOENT
+        # Command not found
+        {
+          stdout: '',
+          stderr: 'Command not found',
+          exit_status: 127
+        }
+      end
+    end
+  end
+end