makit 0.0.139 → 0.0.141

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: 30, 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

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

@@ -1,136 +1,136 @@
-# frozen_string_literal: true
-
-require_relative "base"
-require_relative "synchronous"
-
-module Makit
-  module Commands
-    module Strategies
-      # Factory for creating command execution strategies with fallback support
-      #
-      # This factory allows easy switching between different execution strategies
-      # (ChildProcess, Open3, etc.) with automatic fallback to Open3 if the
-      # preferred strategy fails to load or execute.
-      #
-      # @example Using environment variable to control strategy
-      #   # Use ChildProcess (default)
-      #   MAKIT_STRATEGY=childprocess rake
-      #
-      #   # Force Open3 usage
-      #   MAKIT_STRATEGY=open3 rake
-      #
-      #   # Auto-detect (try ChildProcess, fallback to Open3)
-      #   MAKIT_STRATEGY=auto rake
-      class Factory
-        # Available strategy types
-        STRATEGIES = {
-          'childprocess' => 'ChildProcess',
-          'open3' => 'Synchronous',
-          'auto' => 'AutoDetect'
-        }.freeze
-
-        # Get the configured strategy instance
-        #
-        # @param options [Hash] strategy options
-        # @return [Strategies::Base] configured strategy instance
-        def self.create(options = {})
-          strategy_type = determine_strategy_type
-          
-          begin
-            case strategy_type
-            when 'childprocess'
-              create_childprocess_strategy(options)
-            when 'open3'
-              create_open3_strategy(options)
-            when 'auto'
-              create_auto_detect_strategy(options)
-            else
-              Makit::Logging.warn("Unknown strategy '#{strategy_type}', falling back to Open3") if defined?(Makit::Logging)
-              create_open3_strategy(options)
-            end
-          rescue => e
-            # Ultimate fallback - create basic synchronous strategy
-            Makit::Logging.warn("Failed to create strategy: #{e.message}") if defined?(Makit::Logging)
-            Synchronous.new
-          end
-        end
-
-        # Get the current strategy type from environment or default
-        #
-        # @return [String] strategy type
-        def self.determine_strategy_type
-          env_strategy = ENV['MAKIT_STRATEGY']&.downcase
-          
-          if env_strategy && STRATEGIES.key?(env_strategy)
-            env_strategy
-          else
-            'auto' # Default to auto-detect
-          end
-        end
-
-        # Create ChildProcess strategy with fallback
-        #
-        # @param options [Hash] strategy options
-        # @return [Strategies::Base] strategy instance
-        def self.create_childprocess_strategy(options)
-          begin
-            require_relative 'child_process'
-            ChildProcess.new(**options)
-          rescue LoadError, StandardError => e
-            Makit::Logging.warn("Failed to load ChildProcess strategy: #{e.message}")
-            Makit::Logging.info("Falling back to Open3 strategy")
-            create_open3_strategy(options)
-          end
-        end
-
-        # Create Open3 strategy
-        #
-        # @param options [Hash] strategy options
-        # @return [Strategies::Base] strategy instance
-        def self.create_open3_strategy(options)
-          Synchronous.new(**options)
-        end
-
-        # Create auto-detect strategy that tries ChildProcess first
-        #
-        # @param options [Hash] strategy options
-        # @return [Strategies::Base] strategy instance
-        def self.create_auto_detect_strategy(options)
-          # Always use Open3 for now to avoid circular dependency issues
-          begin
-            Makit::Logging.debug("Using Open3 strategy") if defined?(Makit::Logging)
-            Synchronous.new(**options)
-          rescue => e
-            # Fallback to basic strategy if there are any issues
-            Makit::Logging.warn("Failed to create Open3 strategy: #{e.message}") if defined?(Makit::Logging)
-            Synchronous.new
-          end
-        end
-
-        # Get information about available strategies
-        #
-        # @return [Hash] strategy information
-        def self.strategy_info
-          {
-            current: determine_strategy_type,
-            available: STRATEGIES.keys,
-            childprocess_available: childprocess_available?,
-            open3_available: true # Always available
-          }
-        end
-
-        # Check if ChildProcess strategy is available
-        #
-        # @return [Boolean] true if ChildProcess can be loaded
-        def self.childprocess_available?
-          begin
-            require 'childprocess'
-            true
-          rescue LoadError
-            false
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "synchronous"
+
+module Makit
+  module Commands
+    module Strategies
+      # Factory for creating command execution strategies with fallback support
+      #
+      # This factory allows easy switching between different execution strategies
+      # (ChildProcess, Open3, etc.) with automatic fallback to Open3 if the
+      # preferred strategy fails to load or execute.
+      #
+      # @example Using environment variable to control strategy
+      #   # Use ChildProcess (default)
+      #   MAKIT_STRATEGY=childprocess rake
+      #
+      #   # Force Open3 usage
+      #   MAKIT_STRATEGY=open3 rake
+      #
+      #   # Auto-detect (try ChildProcess, fallback to Open3)
+      #   MAKIT_STRATEGY=auto rake
+      class Factory
+        # Available strategy types
+        STRATEGIES = {
+          'childprocess' => 'ChildProcess',
+          'open3' => 'Synchronous',
+          'auto' => 'AutoDetect'
+        }.freeze
+
+        # Get the configured strategy instance
+        #
+        # @param options [Hash] strategy options
+        # @return [Strategies::Base] configured strategy instance
+        def self.create(options = {})
+          strategy_type = determine_strategy_type
+          
+          begin
+            case strategy_type
+            when 'childprocess'
+              create_childprocess_strategy(options)
+            when 'open3'
+              create_open3_strategy(options)
+            when 'auto'
+              create_auto_detect_strategy(options)
+            else
+              Makit::Logging.warn("Unknown strategy '#{strategy_type}', falling back to Open3") if defined?(Makit::Logging)
+              create_open3_strategy(options)
+            end
+          rescue => e
+            # Ultimate fallback - create basic synchronous strategy
+            Makit::Logging.warn("Failed to create strategy: #{e.message}") if defined?(Makit::Logging)
+            Synchronous.new
+          end
+        end
+
+        # Get the current strategy type from environment or default
+        #
+        # @return [String] strategy type
+        def self.determine_strategy_type
+          env_strategy = ENV['MAKIT_STRATEGY']&.downcase
+          
+          if env_strategy && STRATEGIES.key?(env_strategy)
+            env_strategy
+          else
+            'auto' # Default to auto-detect
+          end
+        end
+
+        # Create ChildProcess strategy with fallback
+        #
+        # @param options [Hash] strategy options
+        # @return [Strategies::Base] strategy instance
+        def self.create_childprocess_strategy(options)
+          begin
+            require_relative 'child_process'
+            ChildProcess.new(**options)
+          rescue LoadError, StandardError => e
+            Makit::Logging.warn("Failed to load ChildProcess strategy: #{e.message}")
+            Makit::Logging.info("Falling back to Open3 strategy")
+            create_open3_strategy(options)
+          end
+        end
+
+        # Create Open3 strategy
+        #
+        # @param options [Hash] strategy options
+        # @return [Strategies::Base] strategy instance
+        def self.create_open3_strategy(options)
+          Synchronous.new(**options)
+        end
+
+        # Create auto-detect strategy that tries ChildProcess first
+        #
+        # @param options [Hash] strategy options
+        # @return [Strategies::Base] strategy instance
+        def self.create_auto_detect_strategy(options)
+          # Always use Open3 for now to avoid circular dependency issues
+          begin
+            Makit::Logging.debug("Using Open3 strategy") if defined?(Makit::Logging)
+            Synchronous.new(**options)
+          rescue => e
+            # Fallback to basic strategy if there are any issues
+            Makit::Logging.warn("Failed to create Open3 strategy: #{e.message}") if defined?(Makit::Logging)
+            Synchronous.new
+          end
+        end
+
+        # Get information about available strategies
+        #
+        # @return [Hash] strategy information
+        def self.strategy_info
+          {
+            current: determine_strategy_type,
+            available: STRATEGIES.keys,
+            childprocess_available: childprocess_available?,
+            open3_available: true # Always available
+          }
+        end
+
+        # Check if ChildProcess strategy is available
+        #
+        # @return [Boolean] true if ChildProcess can be loaded
+        def self.childprocess_available?
+          begin
+            require 'childprocess'
+            true
+          rescue LoadError
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/makit/configuration/timeout.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Makit
+  module Configuration
+    # Configuration for timeouts across the makit system
+    class Timeout
+      # Default timeout values for different operations
+      DEFAULTS = {
+        # Command execution timeouts
+        command: 30,
+        git_clone: 300,
+        git_pull: 120,
+        bundle_install: 300,
+        dotnet_build: 300,
+        dotnet_publish: 300,
+        dotnet_test: 180,
+        dotnet_restore: 120,
+        protoc_generate: 60,
+        gem_build: 300,
+        gem_install: 120,
+        
+        # Strategy timeouts
+        childprocess: 30,
+        open3: 30,
+        
+        # Example execution timeout
+        example: 30
+      }.freeze
+
+      # Get the default timeout for a specific operation
+      #
+      # @param operation [Symbol] the operation type
+      # @return [Integer] timeout in seconds
+      def self.default_for(operation)
+        DEFAULTS[operation] || DEFAULTS[:command]
+      end
+
+      # Get the global default timeout from environment or fallback
+      #
+      # @return [Integer] global default timeout in seconds
+      def self.global_default
+        ENV['MAKIT_DEFAULT_TIMEOUT']&.to_i || DEFAULTS[:command]
+      end
+
+      # Set a custom timeout for an operation
+      #
+      # @param operation [Symbol] the operation type
+      # @param timeout [Integer] timeout in seconds
+      # @return [void]
+      def self.set_timeout(operation, timeout)
+        DEFAULTS[operation] = timeout
+      end
+
+      # Get all configured timeouts
+      #
+      # @return [Hash] all timeout configurations
+      def self.all_timeouts
+        DEFAULTS.dup
+      end
+
+      # Validate a timeout value
+      #
+      # @param timeout [Integer] timeout to validate
+      # @raise [ArgumentError] if timeout is invalid
+      def self.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 (1 hour)"
+      end
+    end
+  end
+end