ukiryu 0.1.0 → 0.1.1

data/lib/ukiryu/extractors/extractor.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require_relative 'base_extractor'
+require_relative 'native_extractor'
+require_relative 'help_parser'
+
+module Ukiryu
+  module Extractors
+    # Main extractor class that orchestrates extraction strategies
+    #
+    # Tries multiple extraction strategies in order:
+    # 1. Native flag extraction (--ukiryu-definition)
+    # 2. Help parsing (--help output)
+    #
+    # @example Extract definition from a tool
+    #   result = Ukiryu::Extractor.extract(:git)
+    #   if result[:success]
+    #     puts result[:yaml]
+    #   else
+    #     puts "Failed: #{result[:error]}"
+    #   end
+    class Extractor
+      # Extract definition from a tool
+      #
+      # Tries multiple extraction strategies in order until one succeeds.
+      #
+      # @param tool_name [String, Symbol] the tool name
+      # @param options [Hash] extraction options
+      # @option options [Symbol] :method specific method to use (:native, :help, :auto)
+      # @option options [Boolean] :verbose enable verbose output
+      # @return [Hash] result with :success, :yaml, :method, :error keys
+      def self.extract(tool_name, options = {})
+        new(tool_name, options).extract
+      end
+
+      # 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 using available strategies
+      #
+      # @return [Hash] result with :success, :yaml, :method, :error keys
+      def extract
+        method = @options[:method] || :auto
+
+        if method == :auto
+          extract_auto
+        elsif method == :native
+          extract_with_native
+        elsif method == :help
+          extract_with_help
+        else
+          {
+            success: false,
+            error: "Unknown extraction method: #{method}",
+            method: nil,
+            yaml: nil
+          }
+        end
+      end
+
+      private
+
+      # Try all extraction strategies in order
+      #
+      # @return [Hash] result hash
+      def extract_auto
+        # Try native flag first
+        result = extract_with_native
+        return result if result[:success]
+
+        # Fall back to help parsing
+        extract_with_help
+      end
+
+      # Extract using native flag
+      #
+      # @return [Hash] result hash
+      def extract_with_native
+        extractor = NativeExtractor.new(@tool_name, @options)
+
+        unless extractor.available?
+          return {
+            success: false,
+            error: "Tool '#{@tool_name}' does not support native definition extraction",
+            method: :native,
+            yaml: nil
+          }
+        end
+
+        yaml = extractor.extract
+
+        if yaml
+          {
+            success: true,
+            yaml: yaml,
+            method: :native,
+            error: nil
+          }
+        else
+          {
+            success: false,
+            error: "Native extraction failed",
+            method: :native,
+            yaml: nil
+          }
+        end
+      end
+
+      # Extract using help parser
+      #
+      # @return [Hash] result hash
+      def extract_with_help
+        extractor = HelpParser.new(@tool_name, @options)
+
+        unless extractor.available?
+          return {
+            success: false,
+            error: "Tool '#{@tool_name}' does not have help output",
+            method: :help,
+            yaml: nil
+          }
+        end
+
+        yaml = extractor.extract
+
+        if yaml
+          {
+            success: true,
+            yaml: yaml,
+            method: :help,
+            error: nil
+          }
+        else
+          {
+            success: false,
+            error: "Help parsing failed",
+            method: :help,
+            yaml: nil
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ukiryu/extractors/help_parser.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require_relative 'base_extractor'
+
+module Ukiryu
+  module Extractors
+    # Help parser extraction strategy
+    #
+    # Reverse-engineers a tool definition by parsing the output
+    # of the tool's `--help` command.
+    class HelpParser < BaseExtractor
+      # Extract definition by parsing help output
+      #
+      # @return [String, nil] the YAML definition or nil if extraction failed
+      def extract
+        return nil unless available?
+
+        help_result = execute_command([@tool_name.to_s, '--help'])
+        return nil unless help_result[:exit_status].zero?
+
+        help_text = help_result[:stdout] + help_result[:stderr]
+        return nil if help_text.strip.empty?
+
+        # Parse help output and generate YAML
+        parse_help_to_yaml(help_text)
+      end
+
+      # Check if the tool has help output
+      #
+      # @return [Boolean] true if --help produces output
+      def available?
+        help_result = execute_command([@tool_name.to_s, '--help'])
+        help_result[:exit_status].zero? && !(help_result[:stdout] + help_result[:stderr]).strip.empty?
+      end
+
+      private
+
+      # Parse help text and convert to YAML format
+      #
+      # @param help_text [String] the help output
+      # @return [String] YAML definition
+      def parse_help_to_yaml(help_text)
+        require 'yaml'
+
+        # Extract tool name from help text (usually first word)
+        name = extract_name(help_text)
+
+        # Try to detect version
+        version = extract_version
+
+        # Build basic YAML structure
+        definition = {
+          'ukiryu_schema' => '1.1',
+          '$self' => "https://www.ukiryu.com/register/1.1/#{name}/#{version || '1.0'}",
+          'name' => name,
+          'version' => version || '1.0',
+          'display_name' => name.capitalize,
+          'profiles' => [
+            {
+              'name' => 'default',
+              'platforms' => %w[macos linux windows],
+              'shells' => %w[bash zsh fish powershell cmd],
+              'commands' => []
+            }
+          ]
+        }
+
+        # Parse commands/options/flags from help text
+        parse_help_elements(help_text, definition)
+
+        definition.to_yaml
+      end
+
+      # Extract tool name from help text
+      #
+      # @param help_text [String] the help output
+      # @return [String] the tool name
+      def extract_name(help_text)
+        # Use the tool name passed to the extractor
+        @tool_name.to_s
+      end
+
+      # Try to detect tool version
+      #
+      # @return [String, nil] the detected version
+      def extract_version
+        version_result = execute_command([@tool_name.to_s, '--version'])
+        if version_result[:exit_status].zero?
+          version_text = version_result[:stdout]
+          # Try to extract version number
+          if version_text =~ /(\d+\.\d+(?:\.\d+)?)/
+            return Regexp.last_match(1)
+          end
+        end
+        nil
+      end
+
+      # Parse help elements (commands, options, flags)
+      #
+      # @param help_text [String] the help output
+      # @param definition [Hash] the definition hash to modify
+      def parse_help_elements(help_text, definition)
+        # This is a basic implementation - real-world parsing would be more sophisticated
+        # For now, we create a basic structure
+
+        lines = help_text.split("\n")
+
+        # Look for option patterns like:
+        #   -v, --verbose
+        #   --output=FILE
+        #   -h, --help
+
+        options = []
+
+        lines.each do |line|
+          # Match short and long options
+          if line =~ /^\s*(-[a-z]),?\s*\[--([a-z-]+)(?:[=\s]+([A-Z_]+))?\]/i
+            short_opt = Regexp.last_match(1)
+            long_opt = Regexp.last_match(2)
+            param = Regexp.last_match(3)
+
+            option = {
+              'name' => long_opt.gsub(/-/, '_'),
+              'description' => line.strip
+            }
+
+            if short_opt
+              option['cli'] = short_opt
+            else
+              option['cli'] = "--#{long_opt}"
+            end
+
+            if param
+              option['type'] = infer_type(param)
+            else
+              option['type'] = 'boolean'
+            end
+
+            options << option
+          elsif line =~ /^\s*\[--([a-z-]+)(?:[=\s]+([A-Z_]+))?\]/i
+            long_opt = Regexp.last_match(1)
+            param = Regexp.last_match(2)
+
+            option = {
+              'name' => long_opt.gsub(/-/, '_'),
+              'cli' => "--#{long_opt}",
+              'description' => line.strip
+            }
+
+            if param
+              option['type'] = infer_type(param)
+            else
+              option['type'] = 'boolean'
+            end
+
+            options << option
+          end
+        end
+
+        # Add default command with parsed options
+        definition['profiles'][0]['commands'] = [
+          {
+            'name' => 'default',
+            'description' => "Default #{@tool_name} command",
+            'options' => options.uniq { |opt| opt['name'] }
+          }
+        ]
+      end
+
+      # Infer type from parameter name
+      #
+      # @param param_name [String] the parameter name
+      # @return [String] the inferred type
+      def infer_type(param_name)
+        case param_name.upcase
+        when /FILE|PATH/
+          'file'
+        when /NUM|COUNT|LEVEL/
+          'integer'
+        when /DIR|FOLDER/
+          'directory'
+        else
+          'string'
+        end
+      end
+    end
+  end
+end

data/lib/ukiryu/extractors/native_extractor.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'base_extractor'
+
+module Ukiryu
+  module Extractors
+    # Native flag extraction strategy
+    #
+    # Attempts to extract definition using the tool's native
+    # `--ukiryu-definition` flag if supported.
+    class NativeExtractor < BaseExtractor
+      # Native flag to try
+      NATIVE_FLAG = '--ukiryu-definition'
+
+      # Extract definition using native flag
+      #
+      # @return [String, nil] the YAML definition or nil if extraction failed
+      def extract
+        return nil unless available?
+
+        result = execute_command([@tool_name.to_s, NATIVE_FLAG])
+
+        return nil unless result[:exit_status].zero?
+        return nil if result[:stdout].strip.empty?
+
+        result[:stdout]
+      end
+
+      # Check if the tool supports native definition extraction
+      #
+      # @return [Boolean] true if the tool exists and the flag is supported
+      def available?
+        # First check if tool exists
+        which_result = execute_command(['which', @tool_name.to_s])
+        return false unless which_result[:exit_status].zero?
+
+        # Then check if it supports the flag
+        help_result = execute_command([@tool_name.to_s, '--help'])
+        return false unless help_result[:exit_status].zero?
+
+        # Check if help mentions ukiryu
+        help_output = help_result[:stdout] + help_result[:stderr]
+        help_output.downcase.include?('ukiryu') || help_output.include?(NATIVE_FLAG)
+      end
+    end
+  end
+end

data/lib/ukiryu/io.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module Ukiryu
+  # I/O stream primitives for CLI tools
+  #
+  # This module defines standard I/O primitives that are common across
+  # command-line tools, providing a consistent interface for:
+  # - Standard input (stdin)
+  # - Standard output (stdout)
+  # - Standard error (stderr)
+  # - Pipes (inter-process communication)
+  # - File redirections
+  #
+  # These are GENERAL PRIMITIVES that apply to ALL CLI tools, not tool-specific.
+
+  # Standard stream marker for stdin
+  STDIN = '-'
+
+  # Standard stream marker for stdout
+  STDOUT = '-'
+  # Also available as "%stdout%" in some tools (Ghostscript)
+
+  # Special value for reading from stdin (double dash)
+  STDIN_MARKER = '--'
+
+  # Standard stream constants
+  module Stream
+    # Standard input stream descriptor
+    #
+    # Used for commands that can read from stdin instead of a file
+    # @example
+    #   # Read from stdin
+    #   tool.options_for(:process).tap do |opts|
+    #     opts.inputs = [Ukiryu::IO::Stream::STDIN]
+    #     opts.output = "output.pdf"
+    #   end
+    STDIN = :stdin
+
+    # Standard output stream descriptor
+    #
+    # Used for commands that can write to stdout instead of a file
+    # @example
+    #   tool.options_for(:export).tap do |opts|
+    #     opts.inputs = ["input.svg"]
+    #     opts.output = Ukiryu::IO::Stream::STDOUT
+    #   end
+    STDOUT = :stdout
+
+    # Standard error stream descriptor
+    #
+    # Used for separating stderr from stdout
+    STDERR = :stderr
+  end
+
+  # Pipe redirection for inter-process communication
+  #
+  # Pipes allow the output of one command to become the input of another.
+  # This is represented by special file path markers.
+  #
+  # @example
+  #   # Pipe output of command1 to command2
+  #   result1 = command1.execute(output: Pipe.to("command2"))
+  #
+  # @example Using special syntax in tools
+  #   # Ghostscript: -sOutputFile=%pipe%lpr
+  #   # Tar: --to-command=COMMAND
+  class Pipe
+    # Special marker for pipe output
+    MARKER = '%pipe%'
+
+    # Create a pipe to a command
+    #
+    # @param command [String] the command to pipe to
+    # @return [String] the pipe marker for use in CLI options
+    #
+    # @example
+    #   Pipe.to("lpr") # => "%pipe%lpr"
+    def self.to(command)
+      "#{MARKER}#{command}"
+    end
+
+    # Parse a pipe marker
+    #
+    # @param value [String] the pipe marker string
+    # @return [String, nil] the command if it's a pipe marker
+    #
+    # @example
+    #   Pipe.parse("%pipe%lpr") # => "lpr"
+    def self.parse(value)
+      return nil unless value.is_a?(String)
+      return nil unless value.start_with?(MARKER)
+
+      value.sub(MARKER, '')
+    end
+
+    # Check if a value is a pipe marker
+    #
+    # @param value [String] the value to check
+    # @return [Boolean] true if it's a pipe marker
+    def self.pipe?(value)
+      return false unless value.is_a?(String)
+
+      value.start_with?(MARKER)
+    end
+  end
+
+  # File redirection primitives
+  #
+  # Provides utilities for file redirection operations
+  module Redirection
+    # Redirect output to a file
+    #
+    # @param output [Symbol, String] :stdout or :stderr
+    # @param path [String] the file path to redirect to
+    # @return [Hash] redirection specification
+    #
+    # @example
+    #   Redirection.to(:stdout, "/tmp/output.txt")
+    def self.to(stream, path)
+      { stream => path }
+    end
+
+    # Redirect stderr to stdout (2>&1 in shell)
+    #
+    # @return [Hash] redirection specification
+    #
+    # @example
+    #   Redirection.stderr_to_stdout
+    def self.stderr_to_stdout
+      { stderr: :stdout }
+    end
+  end
+
+  # Standard input/output file handles
+  #
+  # This class represents special file handles for stdin/stdout/stderr
+  # that are recognized by CLI tools.
+  #
+  # @example
+  #   # Reading from stdin
+  #   input = Ukiryu::IO::StandardInput.new
+  #   input.read
+  #
+  #   # Writing to stdout
+  #   output = Ukiryu::IO::StandardOutput.new
+  #   output.write("data")
+  class StandardInput
+    # The stdin file descriptor
+    FILENO = 0
+
+    # Check if a path represents stdin
+    #
+    # @param path [String, Symbol] the path to check
+    # @return [Boolean] true if the path represents stdin
+    #
+    # @example
+    #   Ukiryu::IO::StandardInput.stdin?("-")  # => true
+    #   Ukiryu::IO::StandardInput.stdin?(:stdin)  # => true
+    def self.stdin?(path)
+      path = path.to_s if path.is_a?(Symbol)
+      [$stdin, '-', '/dev/stdin'].include?(path)
+    end
+  end
+
+  class StandardOutput
+    # The stdout file descriptor
+    FILENO = 1
+
+    # Check if a path represents stdout
+    #
+    # @param path [String, Symbol] the path to check
+    # @return [Boolean] true if the path represents stdout
+    #
+    # @example
+    #   Ukiryu::IO::StandardOutput.stdout?("-")  # => true
+    #   Ukiryu::IO::StandardOutput.stdout?(:stdout)  # => true
+    def self.stdout?(path)
+      path = path.to_s if path.is_a?(Symbol)
+      [$stdout, '-', '/dev/stdout', '%stdout%'].include?(path)
+    end
+  end
+
+  class StandardError
+    # The stderr file descriptor
+    FILENO = 2
+
+    # Check if a path represents stderr
+    #
+    # @param path [String, Symbol] the path to check
+    # @return [Boolean] true if the path represents stderr
+    def self.stderr?(path)
+      path = path.to_s if path.is_a?(Symbol)
+      [:stderr, '/dev/stderr'].include?(path)
+    end
+  end
+end