makit 0.0.140 → 0.0.141

data/lib/makit/commands/strategies/base.rb

@@ -1,171 +1,171 @@
-# frozen_string_literal: true
-
-require "open3"
-require "timeout"
-
-module Makit
-  module Commands
-    module Strategies
-      # Base class for command execution strategies.
-      #
-      # Execution strategies define how commands are actually executed -
-      # synchronously, asynchronously, in parallel, etc. This provides
-      # flexibility in execution patterns while maintaining a consistent
-      # interface.
-      #
-      # @example Creating custom strategy
-      #   class CustomStrategy < Base
-      #     def execute(request)
-      #       # Custom execution logic
-      #       result = Result.new(command: request.to_shell_command)
-      #       # ... perform execution ...
-      #       result.finish!(exit_code: 0, stdout: "success")
-      #     end
-      #   end
-      class Base
-        # Execute a command request.
-        #
-        # This method must be implemented by subclasses to provide the actual
-        # command execution logic. The implementation should create a Result
-        # object and populate it with execution details.
-        #
-        # @param request [Request] the command request to execute
-        # @return [Result] the execution result
-        # @raise [NotImplementedError] if not overridden by subclass
-        def execute(request)
-          raise NotImplementedError, "#{self.class.name} must implement #execute"
-        end
-
-        # Execute multiple requests (default: sequential execution).
-        #
-        # Override this method in subclasses to provide optimized batch execution
-        # such as parallel execution.
-        #
-        # @param requests [Array<Request>] requests to execute
-        # @return [Array<Result>] execution results in same order
-        def execute_batch(requests)
-          requests.map { |request| execute(request) }
-        end
-
-        # Check if this strategy can handle the given request.
-        #
-        # Override this method to provide conditional strategy selection
-        # based on request properties.
-        #
-        # @param request [Request] the command request
-        # @return [Boolean] true if strategy can handle the request
-        def supports?(_request)
-          true
-        end
-
-        # Get strategy name for logging and debugging.
-        #
-        # @return [String] strategy name
-        def name
-          self.class.name.split("::").last
-        end
-
-        # Get strategy configuration.
-        #
-        # @return [Hash] strategy configuration
-        def config
-          {}
-        end
-
-        protected
-
-        # Execute command using Open3 for cross-platform compatibility.
-        #
-        # This is a helper method that subclasses can use for actual
-        # system command execution.
-        #
-        # @param request [Request] the command request
-        # @return [Result] execution result
-        def execute_with_open3(request)
-          result = Result.new(
-            command: request.to_shell_command,
-            started_at: Time.now,
-          )
-
-          begin
-            # Change to specified directory if provided
-            Dir.chdir(request.directory) do
-              # Execute command with timeout using Timeout module
-              stdout, stderr, status = if request.timeout&.positive?
-                  Timeout.timeout(request.timeout) do
-                    Open3.capture3(
-                      request.environment,
-                      request.command,
-                      *request.arguments
-                    )
-                  end
-                else
-                  Open3.capture3(
-                    request.environment,
-                    request.command,
-                    *request.arguments
-                  )
-                end
-
-              result.finish!(
-                exit_code: status.exitstatus,
-                stdout: stdout,
-                stderr: stderr,
-              )
-            end
-          rescue Timeout::Error => e
-            result.finish!(
-              exit_code: 124, # timeout exit code
-              stderr: "Command timed out after #{request.timeout} seconds",
-            ).add_metadata(:timeout, true)
-                  .add_metadata(:error, e.message)
-          rescue StandardError => e
-            result.finish!(
-              exit_code: 1,
-              stderr: e.message,
-            ).add_metadata(:error_class, e.class.name)
-                  .add_metadata(:error, e.message)
-          end
-
-          result
-        end
-
-        # Validate that the command exists and is executable.
-        #
-        # @param command [String] command to validate
-        # @return [Boolean] true if command is available
-        def command_available?(command)
-          # Skip validation for dotnet commands on Windows due to path issues
-          return true if command == "dotnet" && RUBY_PLATFORM.match?(/mswin|mingw/)
-
-          # Try Unix-style which first
-          return true if system("which #{command} > /dev/null 2>&1")
-
-          # Try Windows-style where with proper quoting
-          return true if system("where \"#{command}\" > nul 2>&1")
-
-          # Fallback: try to execute the command directly
-          system("#{command} --version > nul 2>&1") ||
-            system("#{command} --help > nul 2>&1") ||
-            system("#{command} /? > nul 2>&1")
-        end
-
-        # Get the full path to a command.
-        #
-        # @param command [String] command name
-        # @return [String, nil] full path to command or nil if not found
-        def which(command)
-          # Try Unix-style which first
-          path = `which #{command} 2>/dev/null`.strip
-          return path unless path.empty?
-
-          # Try Windows-style where
-          path = `where #{command} 2>nul`.strip
-          return path unless path.empty?
-
-          nil
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+
+module Makit
+  module Commands
+    module Strategies
+      # Base class for command execution strategies.
+      #
+      # Execution strategies define how commands are actually executed -
+      # synchronously, asynchronously, in parallel, etc. This provides
+      # flexibility in execution patterns while maintaining a consistent
+      # interface.
+      #
+      # @example Creating custom strategy
+      #   class CustomStrategy < Base
+      #     def execute(request)
+      #       # Custom execution logic
+      #       result = Result.new(command: request.to_shell_command)
+      #       # ... perform execution ...
+      #       result.finish!(exit_code: 0, stdout: "success")
+      #     end
+      #   end
+      class Base
+        # Execute a command request.
+        #
+        # This method must be implemented by subclasses to provide the actual
+        # command execution logic. The implementation should create a Result
+        # object and populate it with execution details.
+        #
+        # @param request [Request] the command request to execute
+        # @return [Result] the execution result
+        # @raise [NotImplementedError] if not overridden by subclass
+        def execute(request)
+          raise NotImplementedError, "#{self.class.name} must implement #execute"
+        end
+
+        # Execute multiple requests (default: sequential execution).
+        #
+        # Override this method in subclasses to provide optimized batch execution
+        # such as parallel execution.
+        #
+        # @param requests [Array<Request>] requests to execute
+        # @return [Array<Result>] execution results in same order
+        def execute_batch(requests)
+          requests.map { |request| execute(request) }
+        end
+
+        # Check if this strategy can handle the given request.
+        #
+        # Override this method to provide conditional strategy selection
+        # based on request properties.
+        #
+        # @param request [Request] the command request
+        # @return [Boolean] true if strategy can handle the request
+        def supports?(_request)
+          true
+        end
+
+        # Get strategy name for logging and debugging.
+        #
+        # @return [String] strategy name
+        def name
+          self.class.name.split("::").last
+        end
+
+        # Get strategy configuration.
+        #
+        # @return [Hash] strategy configuration
+        def config
+          {}
+        end
+
+        protected
+
+        # Execute command using Open3 for cross-platform compatibility.
+        #
+        # This is a helper method that subclasses can use for actual
+        # system command execution.
+        #
+        # @param request [Request] the command request
+        # @return [Result] execution result
+        def execute_with_open3(request)
+          result = Result.new(
+            command: request.to_shell_command,
+            started_at: Time.now,
+          )
+
+          begin
+            # Change to specified directory if provided
+            Dir.chdir(request.directory) do
+              # Execute command with timeout using Timeout module
+              stdout, stderr, status = if request.timeout&.positive?
+                  Timeout.timeout(request.timeout) do
+                    Open3.capture3(
+                      request.environment,
+                      request.command,
+                      *request.arguments
+                    )
+                  end
+                else
+                  Open3.capture3(
+                    request.environment,
+                    request.command,
+                    *request.arguments
+                  )
+                end
+
+              result.finish!(
+                exit_code: status.exitstatus,
+                stdout: stdout,
+                stderr: stderr,
+              )
+            end
+          rescue Timeout::Error => e
+            result.finish!(
+              exit_code: 124, # timeout exit code
+              stderr: "Command timed out after #{request.timeout} seconds",
+            ).add_metadata(:timeout, true)
+                  .add_metadata(:error, e.message)
+          rescue StandardError => e
+            result.finish!(
+              exit_code: 1,
+              stderr: e.message,
+            ).add_metadata(:error_class, e.class.name)
+                  .add_metadata(:error, e.message)
+          end
+
+          result
+        end
+
+        # Validate that the command exists and is executable.
+        #
+        # @param command [String] command to validate
+        # @return [Boolean] true if command is available
+        def command_available?(command)
+          # Skip validation for dotnet commands on Windows due to path issues
+          return true if command == "dotnet" && RUBY_PLATFORM.match?(/mswin|mingw/)
+
+          # Try Unix-style which first
+          return true if system("which #{command} > /dev/null 2>&1")
+
+          # Try Windows-style where with proper quoting
+          return true if system("where \"#{command}\" > nul 2>&1")
+
+          # Fallback: try to execute the command directly
+          system("#{command} --version > nul 2>&1") ||
+            system("#{command} --help > nul 2>&1") ||
+            system("#{command} /? > nul 2>&1")
+        end
+
+        # Get the full path to a command.
+        #
+        # @param command [String] command name
+        # @return [String, nil] full path to command or nil if not found
+        def which(command)
+          # Try Unix-style which first
+          path = `which #{command} 2>/dev/null`.strip
+          return path unless path.empty?
+
+          # Try Windows-style where
+          path = `where #{command} 2>nul`.strip
+          return path unless path.empty?
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/makit/commands/strategies/child_process.rb

@@ -1,165 +1,165 @@
-# frozen_string_literal: true
-
-require 'childprocess'
-require 'tempfile'
-require_relative "base"
-
-module Makit
-  module Commands
-    module Strategies
-      # ChildProcess-based command execution strategy
-      #
-      # This strategy uses the ChildProcess gem for robust cross-platform
-      # process management. It provides better handling of timeouts, I/O,
-      # and process lifecycle management compared to Open3.
-      #
-      # @example Basic usage
-      #   strategy = ChildProcess.new
-      #   result = strategy.execute(request)
-      #
-      # @example With custom options
-      #   strategy = ChildProcess.new(
-      #     timeout: 60,
-      #     max_output_size: 1_000_000
-      #   )
-      class ChildProcess < Base
-        # @!attribute [r] timeout
-        #   @return [Integer] default timeout in seconds
-        attr_reader :timeout
-
-        # @!attribute [r] max_output_size
-        #   @return [Integer] maximum output size in bytes
-        attr_reader :max_output_size
-
-        # Initialize ChildProcess strategy
-        #
-        # @param timeout [Integer] default timeout in seconds (default: 30)
-        # @param max_output_size [Integer] maximum output size in bytes (default: 1MB)
-        def initialize(timeout: Makit::Configuration::Timeout.global_default, max_output_size: 1_000_000, **options)
-          @timeout = timeout
-          @max_output_size = max_output_size
-          super(**options)
-        end
-
-        # Execute a command request using ChildProcess
-        #
-        # @param request [Request] the command request to execute
-        # @return [Result] execution result
-        def execute(request)
-          result = Result.new(
-            command: request.to_shell_command,
-            started_at: Time.now,
-          )
-
-          stdout_file = nil
-          stderr_file = nil
-          process = nil
-
-          begin
-            # Create temporary files for output
-            stdout_file = Tempfile.new('makit_stdout')
-            stderr_file = Tempfile.new('makit_stderr')
-
-            # Build the process
-            process = ChildProcess.build(request.command, *request.arguments)
-
-            # Set working directory
-            process.cwd = request.directory if request.directory
-
-            # Set environment variables
-            (request.environment || {}).each do |key, value|
-              process.environment[key] = value.to_s
-            end
-
-            # Set up I/O
-            process.io.stdout = stdout_file
-            process.io.stderr = stderr_file
-
-            # Start the process
-            process.start
-
-            # Wait for completion with timeout
-            timeout_seconds = request.timeout || @timeout
-            process.poll_for_exit(timeout_seconds)
-
-            # Read output
-            stdout_file.rewind
-            stderr_file.rewind
-            stdout = stdout_file.read
-            stderr = stderr_file.read
-
-            # Truncate output if too large
-            stdout = truncate_output(stdout, "stdout")
-            stderr = truncate_output(stderr, "stderr")
-
-            result.finish!(
-              exit_code: process.exit_code,
-              stdout: stdout,
-              stderr: stderr,
-            )
-
-          rescue ChildProcess::TimeoutError
-            # Handle timeout
-            process&.stop
-            result.finish!(
-              exit_code: 124,
-              stderr: "Command timed out after #{timeout_seconds} seconds",
-            ).add_metadata(:timeout, true)
-            .add_metadata(:strategy, 'childprocess')
-
-          rescue => e
-            # Handle other errors
-            process&.stop rescue nil
-            result.finish!(
-              exit_code: 1,
-              stderr: e.message,
-            ).add_metadata(:error_class, e.class.name)
-            .add_metadata(:strategy, 'childprocess')
-
-          ensure
-            # Clean up resources
-            [stdout_file, stderr_file].each do |file|
-              file&.close
-              file&.unlink rescue nil
-            end
-          end
-
-          result
-        end
-
-        # Execute multiple requests using ChildProcess
-        #
-        # @param requests [Array<Request>] requests to execute
-        # @return [Array<Result>] execution results
-        def execute_batch(requests)
-          # For now, execute sequentially to avoid complexity
-          # Could be enhanced to use process pools in the future
-          requests.map { |request| execute(request) }
-        end
-
-        private
-
-        # Truncate output if it exceeds maximum size
-        #
-        # @param output [String] output to potentially truncate
-        # @param type [String] output type for logging
-        # @return [String] truncated output
-        def truncate_output(output, type)
-          return output if output.bytesize <= @max_output_size
-
-          original_size = output.bytesize
-          truncated = output.byteslice(0, @max_output_size)
-          
-          Makit::Logging.warn(
-            "#{type.capitalize} truncated",
-            original_size: original_size,
-            max_size: @max_output_size,
-            strategy: 'childprocess'
-          )
-
-          "#{truncated}\n[#{type.upcase} TRUNCATED - Original size: #{original_size} bytes]"
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'childprocess'
+require 'tempfile'
+require_relative "base"
+
+module Makit
+  module Commands
+    module Strategies
+      # ChildProcess-based command execution strategy
+      #
+      # This strategy uses the ChildProcess gem for robust cross-platform
+      # process management. It provides better handling of timeouts, I/O,
+      # and process lifecycle management compared to Open3.
+      #
+      # @example Basic usage
+      #   strategy = ChildProcess.new
+      #   result = strategy.execute(request)
+      #
+      # @example With custom options
+      #   strategy = ChildProcess.new(
+      #     timeout: 60,
+      #     max_output_size: 1_000_000
+      #   )
+      class ChildProcess < Base
+        # @!attribute [r] timeout
+        #   @return [Integer] default timeout in seconds
+        attr_reader :timeout
+
+        # @!attribute [r] max_output_size
+        #   @return [Integer] maximum output size in bytes
+        attr_reader :max_output_size
+
+        # Initialize ChildProcess strategy
+        #
+        # @param timeout [Integer] default timeout in seconds (default: 30)
+        # @param max_output_size [Integer] maximum output size in bytes (default: 1MB)
+        def initialize(timeout: Makit::Configuration::Timeout.global_default, max_output_size: 1_000_000, **options)
+          @timeout = timeout
+          @max_output_size = max_output_size
+          super(**options)
+        end
+
+        # Execute a command request using ChildProcess
+        #
+        # @param request [Request] the command request to execute
+        # @return [Result] execution result
+        def execute(request)
+          result = Result.new(
+            command: request.to_shell_command,
+            started_at: Time.now,
+          )
+
+          stdout_file = nil
+          stderr_file = nil
+          process = nil
+
+          begin
+            # Create temporary files for output
+            stdout_file = Tempfile.new('makit_stdout')
+            stderr_file = Tempfile.new('makit_stderr')
+
+            # Build the process
+            process = ChildProcess.build(request.command, *request.arguments)
+
+            # Set working directory
+            process.cwd = request.directory if request.directory
+
+            # Set environment variables
+            (request.environment || {}).each do |key, value|
+              process.environment[key] = value.to_s
+            end
+
+            # Set up I/O
+            process.io.stdout = stdout_file
+            process.io.stderr = stderr_file
+
+            # Start the process
+            process.start
+
+            # Wait for completion with timeout
+            timeout_seconds = request.timeout || @timeout
+            process.poll_for_exit(timeout_seconds)
+
+            # Read output
+            stdout_file.rewind
+            stderr_file.rewind
+            stdout = stdout_file.read
+            stderr = stderr_file.read
+
+            # Truncate output if too large
+            stdout = truncate_output(stdout, "stdout")
+            stderr = truncate_output(stderr, "stderr")
+
+            result.finish!(
+              exit_code: process.exit_code,
+              stdout: stdout,
+              stderr: stderr,
+            )
+
+          rescue ChildProcess::TimeoutError
+            # Handle timeout
+            process&.stop
+            result.finish!(
+              exit_code: 124,
+              stderr: "Command timed out after #{timeout_seconds} seconds",
+            ).add_metadata(:timeout, true)
+            .add_metadata(:strategy, 'childprocess')
+
+          rescue => e
+            # Handle other errors
+            process&.stop rescue nil
+            result.finish!(
+              exit_code: 1,
+              stderr: e.message,
+            ).add_metadata(:error_class, e.class.name)
+            .add_metadata(:strategy, 'childprocess')
+
+          ensure
+            # Clean up resources
+            [stdout_file, stderr_file].each do |file|
+              file&.close
+              file&.unlink rescue nil
+            end
+          end
+
+          result
+        end
+
+        # Execute multiple requests using ChildProcess
+        #
+        # @param requests [Array<Request>] requests to execute
+        # @return [Array<Result>] execution results
+        def execute_batch(requests)
+          # For now, execute sequentially to avoid complexity
+          # Could be enhanced to use process pools in the future
+          requests.map { |request| execute(request) }
+        end
+
+        private
+
+        # Truncate output if it exceeds maximum size
+        #
+        # @param output [String] output to potentially truncate
+        # @param type [String] output type for logging
+        # @return [String] truncated output
+        def truncate_output(output, type)
+          return output if output.bytesize <= @max_output_size
+
+          original_size = output.bytesize
+          truncated = output.byteslice(0, @max_output_size)
+          
+          Makit::Logging.warn(
+            "#{type.capitalize} truncated",
+            original_size: original_size,
+            max_size: @max_output_size,
+            strategy: 'childprocess'
+          )
+
+          "#{truncated}\n[#{type.upcase} TRUNCATED - Original size: #{original_size} bytes]"
+        end
+      end
+    end
+  end
+end