makit 0.0.112 → 0.0.126

data/lib/makit/commands/request.rb

@@ -1,254 +1,316 @@
-# frozen_string_literal: true
-
-require "shellwords"
-require "json"
-
-module Makit
-  module Commands
-    # Enhanced request handling with validation and type safety.
-    # Uses plain Ruby objects - no protobuf dependency for better performance.
-    #
-    # @example Create a simple request
-    #   request = Request.new(command: "git", arguments: ["--version"])
-    #
-    # @example Create request from string
-    #   request = Request.from_string("git clone https://github.com/user/repo.git")
-    #
-    # @example Create request with full options
-    #   request = Request.new(
-    #     command: "bundle",
-    #     arguments: ["install"],
-    #     directory: "/path/to/project",
-    #     environment: { "BUNDLE_JOBS" => "4" },
-    #     timeout: 300,
-    #     metadata: { operation: "dependency_install" }
-    #   )
-    class Request
-      # Command execution request with validation and metadata.
-      #
-      # @!attribute [r] command
-      #   @return [String] the command to execute
-      # @!attribute [r] arguments
-      #   @return [Array<String>] command line arguments
-      # @!attribute [r] environment
-      #   @return [Hash<String,String>] environment variables
-      # @!attribute [r] directory
-      #   @return [String] working directory for execution
-      # @!attribute [r] timeout
-      #   @return [Integer] timeout in seconds
-      # @!attribute [r] metadata
-      #   @return [Hash] additional metadata for logging/tracking
-      attr_reader :command, :arguments, :environment, :directory, :timeout, :metadata
-
-      # Initialize a new command request.
-      #
-      # @param command [String] the command to execute
-      # @param arguments [Array<String>] command arguments
-      # @param environment [Hash<String,String>] environment variables
-      # @param directory [String] working directory
-      # @param timeout [Integer] timeout in seconds
-      # @param metadata [Hash] additional metadata
-      # @raise [ArgumentError] if command is invalid
-      def initialize(command:, arguments: [], **options)
-        @command = validate_command(command)
-        @arguments = validate_arguments(arguments)
-        @environment = options[:environment] || {}
-        @directory = options[:directory] || Dir.pwd
-        @timeout = options[:timeout] || 30
-        @metadata = options[:metadata] || {}
-
-        validate_directory(@directory)
-        validate_timeout(@timeout)
-      end
-
-      # Convert request to shell-executable command string.
-      #
-      # @return [String] shell command string
-      def to_shell_command
-        cmd_parts = [command] + arguments
-        Shellwords.join(cmd_parts)
-      end
-
-      # Convert request to hash representation.
-      #
-      # @return [Hash] hash representation of the request
-      def to_h
-        {
-          command: command,
-          arguments: arguments,
-          environment: environment,
-          directory: directory,
-          timeout: timeout,
-          metadata: metadata,
-        }
-      end
-
-      # Convert request to JSON representation.
-      #
-      # @param args [Array] arguments passed to JSON.generate
-      # @return [String] JSON representation
-      def to_json(*args)
-        JSON.generate(to_h, *args)
-      end
-
-      # Create a request from a shell command string.
-      #
-      # @param command_string [String] shell command string to parse
-      # @param options [Hash] additional options
-      # @return [Request] new request object
-      # @raise [ArgumentError] if command string is invalid
-      # @example
-      #   Request.from_string("git clone https://github.com/user/repo.git")
-      #   Request.from_string("bundle install --jobs 4")
-      def self.from_string(command_string, **options)
-        raise ArgumentError, "Command string cannot be empty" if command_string.nil? || command_string.strip.empty?
-
-        # Parse shell command string into command and arguments
-        parts = Shellwords.split(command_string.strip)
-        command = parts.shift
-        arguments = parts
-
-        new(command: command, arguments: arguments, **options)
-      end
-
-      # Create a request from hash representation.
-      #
-      # @param command_hash [Hash] hash containing command information
-      # @return [Request] new request object
-      # @raise [ArgumentError] if hash is invalid
-      # @example
-      #   Request.from_hash({
-      #     "command" => "git",
-      #     "arguments" => ["clone", "https://github.com/user/repo.git"],
-      #     "timeout" => 300
-      #   })
-      def self.from_hash(command_hash)
-        raise ArgumentError, "Command hash cannot be nil" if command_hash.nil?
-
-        # Convert string keys to symbols for consistency
-        hash = command_hash.is_a?(Hash) ? normalize_hash_keys(command_hash) : command_hash
-
-        new(
-          command: hash[:command] || hash["command"],
-          arguments: hash[:arguments] || hash["arguments"] || [],
-          environment: hash[:environment] || hash["environment"] || {},
-          directory: hash[:directory] || hash["directory"],
-          timeout: hash[:timeout] || hash["timeout"],
-          metadata: hash[:metadata] || hash["metadata"] || {},
-        )
-      end
-
-      # Create a request from JSON string.
-      #
-      # @param json_string [String] JSON string representation
-      # @return [Request] new request object
-      # @raise [JSON::ParserError, ArgumentError] if JSON is invalid
-      def self.from_json(json_string)
-        hash = JSON.parse(json_string)
-        from_hash(hash)
-      end
-
-      # Check if this request represents the same command.
-      #
-      # @param other [Request] another request to compare
-      # @return [Boolean] true if commands are equivalent
-      def equivalent_to?(other)
-        return false unless other.is_a?(Request)
-
-        command == other.command &&
-          arguments == other.arguments &&
-          environment == other.environment &&
-          directory == other.directory
-      end
-
-      # Generate a cache key for this request.
-      #
-      # @return [String] cache key based on command, arguments, and context
-      def cache_key
-        require "digest"
-        content = "#{command}:#{arguments.join(":")}:#{directory}"
-        Digest::SHA256.hexdigest(content)[0..16]
-      end
-
-      private
-
-      # Validate command parameter.
-      #
-      # @param command [String] command to validate
-      # @return [String] validated command
-      # @raise [ArgumentError] if command is invalid
-      def validate_command(command)
-        raise ArgumentError, "Command cannot be nil" if command.nil?
-        raise ArgumentError, "Command cannot be empty" if command.strip.empty?
-
-        cmd = command.strip
-
-        # Check for dangerous characters that could indicate command injection
-        raise ArgumentError, "Command contains potentially dangerous characters" if cmd.match?(/[;&|`$(){}]/)
-
-        cmd
-      end
-
-      # Validate arguments array.
-      #
-      # @param arguments [Array] arguments to validate
-      # @return [Array<String>] validated arguments
-      # @raise [ArgumentError] if arguments are invalid
-      def validate_arguments(arguments)
-        return [] if arguments.nil?
-        raise ArgumentError, "Arguments must be an array" unless arguments.is_a?(Array)
-
-        # Convert all arguments to strings and validate
-        arguments.map do |arg|
-          raise ArgumentError, "Argument cannot be nil" if arg.nil?
-
-          arg.to_s
-        end
-      end
-
-      # Validate directory parameter.
-      #
-      # @param directory [String] directory to validate
-      # @raise [ArgumentError] if directory is invalid
-      def validate_directory(directory)
-        return unless directory
-
-        raise ArgumentError, "Directory must be a string" unless directory.is_a?(String)
-
-        # NOTE: We don't validate directory existence here as it might be created later
-        # We just validate it's a reasonable path format
-        return unless directory.include?("\0")
-
-        raise ArgumentError, "Directory path contains null bytes"
-      end
-
-      # Validate timeout parameter.
-      #
-      # @param timeout [Integer] timeout to validate
-      # @raise [ArgumentError] if timeout is invalid
-      def validate_timeout(timeout)
-        raise ArgumentError, "Timeout must be a positive integer" unless timeout.is_a?(Integer) && timeout.positive?
-
-        return unless timeout > 3600 # 1 hour max
-
-        raise ArgumentError, "Timeout cannot exceed 3600 seconds"
-      end
-
-      # Normalize hash keys to support both string and symbol keys.
-      #
-      # @param hash [Hash] hash to normalize
-      # @return [Hash] hash with normalized keys
-      def self.normalize_hash_keys(hash)
-        normalized = {}
-        hash.each do |key, value|
-          normalized_key = key.is_a?(String) ? key.to_sym : key
-          normalized[key] = value # Keep original key
-          normalized[normalized_key] = value # Add symbol version
-        end
-        normalized
-      end
-
-      private_class_method :normalize_hash_keys
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "shellwords"
+require "json"
+
+module Makit
+  module Commands
+    # Enhanced request handling with validation and type safety.
+    # Uses plain Ruby objects - no protobuf dependency for better performance.
+    #
+    # @example Create a simple request
+    #   request = Request.new(command: "git", arguments: ["--version"])
+    #
+    # @example Create request from string
+    #   request = Request.from_string("git clone https://github.com/user/repo.git")
+    #
+    # @example Create request with full options
+    #   request = Request.new(
+    #     command: "bundle",
+    #     arguments: ["install"],
+    #     directory: "/path/to/project",
+    #     environment: { "BUNDLE_JOBS" => "4" },
+    #     timeout: 300,
+    #     metadata: { operation: "dependency_install" }
+    #   )
+    class Request
+      # Command execution request with validation and metadata.
+      #
+      # @!attribute [r] command
+      #   @return [String] the command to execute
+      # @!attribute [r] arguments
+      #   @return [Array<String>] command line arguments
+      # @!attribute [r] environment
+      #   @return [Hash<String,String>] environment variables
+      # @!attribute [r] directory
+      #   @return [String] working directory for execution
+      # @!attribute [r] timeout
+      #   @return [Integer] timeout in seconds
+      # @!attribute [r] metadata
+      #   @return [Hash] additional metadata for logging/tracking
+      attr_reader :command, :arguments, :environment, :directory, :timeout, :metadata
+      attr_writer :exit_on_failure, :show_stderr, :show_stdout
+
+      # Initialize a new command request.
+      #
+      # @param command [String] the command to execute
+      # @param arguments [Array<String>] command arguments
+      # @param environment [Hash<String,String>] environment variables
+      # @param directory [String] working directory
+      # @param timeout [Integer] timeout in seconds
+      # @param metadata [Hash] additional metadata
+      # @raise [ArgumentError] if command is invalid
+      def initialize(command:, arguments: [], **options)
+        @command = validate_command(command)
+        @arguments = validate_arguments(arguments)
+        @environment = options[:environment] || {}
+        @directory = options[:directory] || Dir.pwd
+        @timeout = options[:timeout] || 30
+        @metadata = options[:metadata] || {}
+        @exit_on_failure = options[:exit_on_failure] || true
+        @show_stderr = options[:show_stderr] || true
+        @show_stdout = options[:show_stdout] || false
+        validate_directory(@directory)
+        validate_timeout(@timeout)
+      end
+
+      # Convert request to shell-executable command string.
+      #
+      # @return [String] shell command string
+      def to_shell_command
+        cmd_parts = [command] + arguments
+        Shellwords.join(cmd_parts)
+      end
+
+      # Convert request to hash representation.
+      #
+      # @return [Hash] hash representation of the request
+      def to_h
+        {
+          command: command,
+          arguments: arguments,
+          environment: environment,
+          directory: directory,
+          timeout: timeout,
+          metadata: metadata,
+          exit_on_failure: exit_on_failure?,
+          show_stderr: show_stderr?,
+          show_stdout: show_stdout?,
+        }
+      end
+
+      # Convert request to JSON representation.
+      #
+      # @param args [Array] arguments passed to JSON.generate
+      # @return [String] JSON representation
+      def to_json(*args)
+        JSON.generate(to_h, *args)
+      end
+
+      def to_json_pretty(*args)
+        JSON.pretty_generate(to_h, *args)
+      end
+
+      # Create a request from a shell command string.
+      #
+      # @param command_string [String] shell command string to parse
+      # @param options [Hash] additional options
+      # @return [Request] new request object
+      # @raise [ArgumentError] if command string is invalid
+      # @example
+      #   Request.from_string("git clone https://github.com/user/repo.git")
+      #   Request.from_string("bundle install --jobs 4")
+      def self.from_string(command_string, **options)
+        raise ArgumentError, "Command string cannot be empty" if command_string.nil? || command_string.strip.empty?
+
+        # Parse shell command string into command and arguments
+        parts = Shellwords.split(command_string.strip)
+        command = parts.shift
+        arguments = parts
+
+        new(command: command, arguments: arguments, **options)
+      end
+
+      # Create a request from hash representation.
+      #
+      # @param command_hash [Hash] hash containing command information
+      # @return [Request] new request object
+      # @raise [ArgumentError] if hash is invalid
+      # @example
+      #   Request.from_hash({
+      #     "command" => "git",
+      #     "arguments" => ["clone", "https://github.com/user/repo.git"],
+      #     "timeout" => 300
+      #   })
+      def self.from_hash(command_hash)
+        raise ArgumentError, "Command hash cannot be nil" if command_hash.nil?
+
+        # Convert string keys to symbols for consistency
+        hash = command_hash.is_a?(Hash) ? normalize_hash_keys(command_hash) : command_hash
+
+        new(
+          command: hash[:command] || hash["command"],
+          arguments: hash[:arguments] || hash["arguments"] || [],
+          environment: hash[:environment] || hash["environment"] || {},
+          directory: hash[:directory] || hash["directory"],
+          timeout: hash[:timeout] || hash["timeout"],
+          metadata: hash[:metadata] || hash["metadata"] || {},
+          exit_on_failure: hash[:exit_on_failure] || hash["exit_on_failure"],
+          show_stderr: hash[:show_stderr] || hash["show_stderr"],
+          show_stdout: hash[:show_stdout] || hash["show_stdout"],
+        )
+      end
+
+      # Create a request from JSON string.
+      #
+      # @param json_string [String] JSON string representation
+      # @return [Request] new request object
+      # @raise [JSON::ParserError, ArgumentError] if JSON is invalid
+      def self.from_json(json_string)
+        hash = JSON.parse(json_string)
+        from_hash(hash)
+      end
+
+      # Check if this request represents the same command.
+      #
+      # @param other [Request] another request to compare
+      # @return [Boolean] true if commands are equivalent
+      def equivalent_to?(other)
+        return false unless other.is_a?(Request)
+
+        command == other.command &&
+          arguments == other.arguments &&
+          environment == other.environment &&
+          directory == other.directory
+      end
+
+      # Generate a cache key for this request.
+      #
+      # @return [String] cache key based on command, arguments, and context
+      def cache_key
+        require "digest"
+        content = "#{command}:#{arguments.join(":")}:#{directory}"
+        Digest::SHA256.hexdigest(content)[0..16]
+      end
+
+      def exit_on_failure?
+        @exit_on_failure
+      end
+
+      def exit_on_failure(exit_on_failure)
+        @exit_on_failure = exit_on_failure
+        self
+      end
+
+      def show_stderr?
+        @show_stderr
+      end
+
+      def show_stderr(show_stderr)
+        @show_stderr = show_stderr
+        self
+      end
+
+      def show_stdout?
+        @show_stdout
+      end
+
+      def show_stdout(show_stdout)
+        @show_stdout = show_stdout
+        self
+      end
+
+      # Execute the command.
+      #
+      # @return [Result] execution result
+      # @raise [ArgumentError] if runner is not set
+      def run
+        # self.exit_on_failure = exit_on_failure
+        # self.show_stderr = true
+        result = Makit::Commands::Runner.default.execute(show_stderr(true))
+
+        # Display stderr if the command failed and show_stderr is enabled
+        puts result.stderr if result.failure? && show_stderr? && !result.stderr.empty?
+
+        # Exit with the command's exit code if it failed and exit_on_failure is enabled
+        exit result.exit_code if result.failure? && exit_on_failure?
+
+        result
+      end
+
+      def try
+        Makit::Commands::Runner.default.execute(exit_on_failure(false))
+      end
+
+      private
+
+      # Validate command parameter.
+      #
+      # @param command [String] command to validate
+      # @return [String] validated command
+      # @raise [ArgumentError] if command is invalid
+      def validate_command(command)
+        raise ArgumentError, "Command cannot be nil" if command.nil?
+        raise ArgumentError, "Command cannot be empty" if command.strip.empty?
+
+        cmd = command.strip
+
+        # Check for dangerous characters that could indicate command injection
+        raise ArgumentError, "Command contains potentially dangerous characters" if cmd.match?(/[;&|`$(){}]/)
+
+        cmd
+      end
+
+      # Validate arguments array.
+      #
+      # @param arguments [Array] arguments to validate
+      # @return [Array<String>] validated arguments
+      # @raise [ArgumentError] if arguments are invalid
+      def validate_arguments(arguments)
+        return [] if arguments.nil?
+        raise ArgumentError, "Arguments must be an array" unless arguments.is_a?(Array)
+
+        # Convert all arguments to strings and validate
+        arguments.map do |arg|
+          raise ArgumentError, "Argument cannot be nil" if arg.nil?
+
+          arg.to_s
+        end
+      end
+
+      # Validate directory parameter.
+      #
+      # @param directory [String] directory to validate
+      # @raise [ArgumentError] if directory is invalid
+      def validate_directory(directory)
+        return unless directory
+
+        raise ArgumentError, "Directory must be a string" unless directory.is_a?(String)
+
+        # NOTE: We don't validate directory existence here as it might be created later
+        # We just validate it's a reasonable path format
+        return unless directory.include?("\0")
+
+        raise ArgumentError, "Directory path contains null bytes"
+      end
+
+      # Validate timeout parameter.
+      #
+      # @param timeout [Integer] timeout to validate
+      # @raise [ArgumentError] if timeout is invalid
+      def validate_timeout(timeout)
+        raise ArgumentError, "Timeout must be a positive integer" unless timeout.is_a?(Integer) && timeout.positive?
+
+        return unless timeout > 3600 # 1 hour max
+
+        raise ArgumentError, "Timeout cannot exceed 3600 seconds"
+      end
+
+      # Normalize hash keys to support both string and symbol keys.
+      #
+      # @param hash [Hash] hash to normalize
+      # @return [Hash] hash with normalized keys
+      def self.normalize_hash_keys(hash)
+        normalized = {}
+        hash.each do |key, value|
+          normalized_key = key.is_a?(String) ? key.to_sym : key
+          normalized[key] = value # Keep original key
+          normalized[normalized_key] = value # Add symbol version
+        end
+        normalized
+      end
+
+      private_class_method :normalize_hash_keys
+    end
+  end
+end