makit 0.0.164 → 0.0.166

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/commands/strategies/synchronous.rb

@@ -1,139 +1,139 @@
-# frozen_string_literal: true
-
-require_relative "base"
-require_relative "../result"
-
-module Makit
-  module Commands
-    module Strategies
-      # Synchronous command execution strategy.
-      #
-      # This strategy executes commands one at a time, blocking until each
-      # command completes. This is the simplest and most reliable execution
-      # pattern, suitable for most use cases.
-      #
-      # @example Using synchronous execution
-      #   strategy = Synchronous.new
-      #   request = Request.new(command: "echo", arguments: ["hello"])
-      #   result = strategy.execute(request)
-      #   puts result.stdout # "hello"
-      class Synchronous < Base
-        # Initialize synchronous execution strategy.
-        #
-        # @param options [Hash] strategy configuration
-        # @option options [Boolean] :validate_commands (true) whether to validate commands exist
-        # @option options [Integer] :max_output_size (1048576) maximum output size in bytes
-        def initialize(**options)
-          @validate_commands = false # Always disable validation to avoid path issues
-          @max_output_size = options.fetch(:max_output_size, 1024 * 1024) # 1MB default
-        end
-
-        # Execute a single command request synchronously.
-        #
-        # @param request [Request] the command request to execute
-        # @return [Result] execution result
-        def execute(request)
-          # Skip command validation for basic commands like echo on Windows
-          # This is a simplified approach for demonstration purposes
-          if @validate_commands && !basic_command?(request.command) && !command_available?(request.command)
-            # For dotnet commands, try to execute anyway as validation might be unreliable
-            if request.command == "dotnet"
-              Makit::Logging.debug("Skipping validation for dotnet command due to potential path issues")
-            else
-              return Result.failure(
-                       command: request.to_shell_command,
-                       error: "Command not found: #{request.command}",
-                     )
-            end
-          end
-
-          # Execute using Open3 for cross-platform support
-          result = execute_with_open3(request)
-
-          # Truncate output if too large
-          if result.stdout.bytesize > @max_output_size
-            original_size = result.stdout.bytesize
-            truncated_stdout = result.stdout.byteslice(0, @max_output_size)
-            result.instance_variable_set(:@stdout, "#{truncated_stdout}\n[OUTPUT TRUNCATED]")
-            result.add_metadata(:output_truncated, true)
-            result.add_metadata(:original_stdout_size, original_size)
-          end
-
-          if result.stderr.bytesize > @max_output_size
-            original_size = result.stderr.bytesize
-            truncated_stderr = result.stderr.byteslice(0, @max_output_size)
-            result.instance_variable_set(:@stderr, "#{truncated_stderr}\n[ERROR OUTPUT TRUNCATED]")
-            result.add_metadata(:stderr_truncated, true)
-            result.add_metadata(:original_stderr_size, original_size)
-          end
-
-          # Add strategy metadata
-          result.add_metadata(:execution_strategy, "synchronous")
-          result.add_metadata(:validated_command, @validate_commands)
-
-          result
-        end
-
-        # Execute multiple requests sequentially.
-        #
-        # @param requests [Array<Request>] requests to execute
-        # @return [Array<Result>] execution results in same order
-        def execute_batch(requests)
-          results = []
-
-          requests.each_with_index do |request, index|
-            result = execute(request)
-            result.add_metadata(:batch_index, index)
-            result.add_metadata(:batch_size, requests.size)
-            results << result
-
-            # Stop on first failure if configured
-            break if result.failure? && fail_fast?
-          end
-
-          results
-        end
-
-        # Check if strategy supports the given request.
-        #
-        # Synchronous strategy supports all requests.
-        #
-        # @param request [Request] the command request
-        # @return [Boolean] always true
-        def supports?(_request)
-          true
-        end
-
-        # Get strategy configuration.
-        #
-        # @return [Hash] strategy configuration
-        def config
-          {
-            name: "synchronous",
-            validate_commands: @validate_commands,
-            max_output_size: @max_output_size,
-            fail_fast: fail_fast?,
-          }
-        end
-
-        private
-
-        # Check if command is a basic system command that should always be available.
-        #
-        # @param command [String] command name
-        # @return [Boolean] true if it's a basic command
-        def basic_command?(command)
-          %w[echo ruby bundle rake git dotnet].include?(command)
-        end
-
-        # Check if execution should stop on first failure.
-        #
-        # @return [Boolean] whether to fail fast
-        def fail_fast?
-          # Could be configurable in the future
-          false
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../result"
+
+module Makit
+  module Commands
+    module Strategies
+      # Synchronous command execution strategy.
+      #
+      # This strategy executes commands one at a time, blocking until each
+      # command completes. This is the simplest and most reliable execution
+      # pattern, suitable for most use cases.
+      #
+      # @example Using synchronous execution
+      #   strategy = Synchronous.new
+      #   request = Request.new(command: "echo", arguments: ["hello"])
+      #   result = strategy.execute(request)
+      #   puts result.stdout # "hello"
+      class Synchronous < Base
+        # Initialize synchronous execution strategy.
+        #
+        # @param options [Hash] strategy configuration
+        # @option options [Boolean] :validate_commands (true) whether to validate commands exist
+        # @option options [Integer] :max_output_size (1048576) maximum output size in bytes
+        def initialize(**options)
+          @validate_commands = false # Always disable validation to avoid path issues
+          @max_output_size = options.fetch(:max_output_size, 1024 * 1024) # 1MB default
+        end
+
+        # Execute a single command request synchronously.
+        #
+        # @param request [Request] the command request to execute
+        # @return [Result] execution result
+        def execute(request)
+          # Skip command validation for basic commands like echo on Windows
+          # This is a simplified approach for demonstration purposes
+          if @validate_commands && !basic_command?(request.command) && !command_available?(request.command)
+            # For dotnet commands, try to execute anyway as validation might be unreliable
+            if request.command == "dotnet"
+              Makit::Logging.debug("Skipping validation for dotnet command due to potential path issues")
+            else
+              return Result.failure(
+                       command: request.to_shell_command,
+                       error: "Command not found: #{request.command}",
+                     )
+            end
+          end
+
+          # Execute using Open3 for cross-platform support
+          result = execute_with_open3(request)
+
+          # Truncate output if too large
+          if result.stdout.bytesize > @max_output_size
+            original_size = result.stdout.bytesize
+            truncated_stdout = result.stdout.byteslice(0, @max_output_size)
+            result.instance_variable_set(:@stdout, "#{truncated_stdout}\n[OUTPUT TRUNCATED]")
+            result.add_metadata(:output_truncated, true)
+            result.add_metadata(:original_stdout_size, original_size)
+          end
+
+          if result.stderr.bytesize > @max_output_size
+            original_size = result.stderr.bytesize
+            truncated_stderr = result.stderr.byteslice(0, @max_output_size)
+            result.instance_variable_set(:@stderr, "#{truncated_stderr}\n[ERROR OUTPUT TRUNCATED]")
+            result.add_metadata(:stderr_truncated, true)
+            result.add_metadata(:original_stderr_size, original_size)
+          end
+
+          # Add strategy metadata
+          result.add_metadata(:execution_strategy, "synchronous")
+          result.add_metadata(:validated_command, @validate_commands)
+
+          result
+        end
+
+        # Execute multiple requests sequentially.
+        #
+        # @param requests [Array<Request>] requests to execute
+        # @return [Array<Result>] execution results in same order
+        def execute_batch(requests)
+          results = []
+
+          requests.each_with_index do |request, index|
+            result = execute(request)
+            result.add_metadata(:batch_index, index)
+            result.add_metadata(:batch_size, requests.size)
+            results << result
+
+            # Stop on first failure if configured
+            break if result.failure? && fail_fast?
+          end
+
+          results
+        end
+
+        # Check if strategy supports the given request.
+        #
+        # Synchronous strategy supports all requests.
+        #
+        # @param request [Request] the command request
+        # @return [Boolean] always true
+        def supports?(_request)
+          true
+        end
+
+        # Get strategy configuration.
+        #
+        # @return [Hash] strategy configuration
+        def config
+          {
+            name: "synchronous",
+            validate_commands: @validate_commands,
+            max_output_size: @max_output_size,
+            fail_fast: fail_fast?,
+          }
+        end
+
+        private
+
+        # Check if command is a basic system command that should always be available.
+        #
+        # @param command [String] command name
+        # @return [Boolean] true if it's a basic command
+        def basic_command?(command)
+          %w[echo ruby bundle rake git dotnet].include?(command)
+        end
+
+        # Check if execution should stop on first failure.
+        #
+        # @return [Boolean] whether to fail fast
+        def fail_fast?
+          # Could be configurable in the future
+          false
+        end
+      end
+    end
+  end
+end

data/lib/makit/commands.rb

@@ -1,50 +1,50 @@
-# frozen_string_literal: true
-
-require "English"
-require "open3"
-require "socket"
-require "etc"
-require "logger"
-
-# This module provides classes for the Makit gem.
-module Makit
-  # Commands module provides a modern, flexible command execution framework
-  # with middleware support, validation, caching, and structured logging.
-  module Commands
-    # Custom exception for security-related command validation failures
-    class SecurityError < StandardError; end
-
-    # Custom exception for command execution failures
-    class ExecutionError < StandardError
-      attr_reader :exit_code, :stderr
-
-      def initialize(message, exit_code: nil, stderr: nil)
-        @exit_code = exit_code
-        @stderr = stderr
-        super(message)
-      end
-    end
-  end
-
-  # This class provide methods running commands.
-  #
-  class LegacyCommands < Array
-    # Generate the commands based on the current directory.
-    def auto_generate
-      self << Makit::V1::CommandRequest.new(name: "bundle", arguments: ["install"]) if File.exist?("Gemfile")
-      self << Makit::V1::CommandRequest.new(name: "bundle", arguments: %w[exec rake]) if File.exist?("Rakefile")
-    end
-  end
-end
-
-# Load command system components (load existing components only)
-require_relative "commands/result"
-require_relative "commands/request"
-require_relative "commands/runner"
-require_relative "commands/factory"
-require_relative "commands/middleware/validator"
-require_relative "commands/middleware/cache"
-require_relative "commands/middleware/command_logger"
-require_relative "commands/middleware/base"
-require_relative "commands/strategies/base"
-require_relative "commands/strategies/synchronous"
+# frozen_string_literal: true
+
+require "English"
+require "open3"
+require "socket"
+require "etc"
+require "logger"
+
+# This module provides classes for the Makit gem.
+module Makit
+  # Commands module provides a modern, flexible command execution framework
+  # with middleware support, validation, caching, and structured logging.
+  module Commands
+    # Custom exception for security-related command validation failures
+    class SecurityError < StandardError; end
+
+    # Custom exception for command execution failures
+    class ExecutionError < StandardError
+      attr_reader :exit_code, :stderr
+
+      def initialize(message, exit_code: nil, stderr: nil)
+        @exit_code = exit_code
+        @stderr = stderr
+        super(message)
+      end
+    end
+  end
+
+  # This class provide methods running commands.
+  #
+  class LegacyCommands < Array
+    # Generate the commands based on the current directory.
+    def auto_generate
+      self << Makit::V1::CommandRequest.new(name: "bundle", arguments: ["install"]) if File.exist?("Gemfile")
+      self << Makit::V1::CommandRequest.new(name: "bundle", arguments: %w[exec rake]) if File.exist?("Rakefile")
+    end
+  end
+end
+
+# Load command system components (load existing components only)
+require_relative "commands/result"
+require_relative "commands/request"
+require_relative "commands/runner"
+require_relative "commands/factory"
+require_relative "commands/middleware/validator"
+require_relative "commands/middleware/cache"
+require_relative "commands/middleware/command_logger"
+require_relative "commands/middleware/base"
+require_relative "commands/strategies/base"
+require_relative "commands/strategies/synchronous"