makit 0.0.139 → 0.0.140

data/lib/makit/commands/runner.rb

@@ -1,385 +1,385 @@
-# frozen_string_literal: true
-
-require_relative "request"
-require_relative "result"
-require_relative "strategies/synchronous"
-require_relative "strategies/factory"
-require_relative "middleware/base"
-require_relative "middleware/command_logger"
-
-module Makit
-  module Commands
-    # Modern command execution engine with proper separation of concerns.
-    #
-    # The Runner coordinates command execution through a middleware chain and
-    # execution strategies. It provides a clean, extensible architecture for
-    # command processing with support for caching, logging, validation, and
-    # custom execution patterns.
-    #
-    # @example Basic usage
-    #   runner = Runner.new
-    #   request = Request.from_string("git --version")
-    #   result = runner.execute(request)
-    #   puts result.stdout
-    #
-    # @example With custom middleware
-    #   runner = Runner.new(middleware: [Logger.new, Cache.new])
-    #   result = runner.execute(request)
-    #
-    # @example With custom strategy
-    #   runner = Runner.new(strategy: Strategies::Parallel.new)
-    #   results = runner.execute_batch(requests)
-    class Runner
-      # @!attribute [r] middleware
-      #   @return [Array<Middleware::Base>] middleware chain
-      # @!attribute [r] strategy
-      #   @return [Strategies::Base] execution strategy
-      attr_reader :middleware, :strategy
-
-      # Get the default configured runner instance.
-      #
-      # @return [Runner] default runner with standard middleware
-      def self.default
-        # Recreate the runner if the log level has changed
-        current_log_level = defined?(Makit::Logging) ? Makit::Logging.current_log_level : :info
-        if @default.nil? || @last_log_level != current_log_level
-          @last_log_level = current_log_level
-          begin
-            @default = new(
-              middleware: [
-                Middleware::CommandLogger.new(
-                  log_stdout: true,
-                  log_stderr: true,
-                  log_performance: true,
-                  max_output_lines: 50,
-                ),
-              ],
-            )
-          rescue => e
-            # Fallback to basic runner if there are issues
-            @default = new
-          end
-        end
-        @default
-      end
-
-      # Initialize a new command runner.
-      #
-      # @param middleware [Array<Middleware::Base>] middleware chain
-      # @param strategy [Strategies::Base] execution strategy
-      # @param options [Hash] additional configuration
-      def initialize(middleware: nil, strategy: nil, **options)
-        @middleware = Array(middleware || default_middleware)
-        @strategy = strategy || Strategies::Factory.create(options)
-        @options = options
-
-        validate_middleware
-        validate_strategy
-
-        # Log runner initialization
-        log_runner_initialization
-      end
-
-      # Execute a single command request.
-      #
-      # @param request [Request, String, Hash] command request to execute
-      # @return [Result] execution result
-      # @raise [ArgumentError] if request is invalid
-      def execute(request)
-        Makit::Logging.debug("Makit::Commands::Runner.execute starting")
-        # Makit::Logging.debug("Executing request: #{request.to_json_pretty}")
-        # Normalize request to Request object
-        normalized_request = normalize_request(request)
-
-        # Apply middleware chain
-        Makit::Logging.debug("Makit::Commands::Runner.execute applying middleware chain")
-        result = execute_with_middleware(normalized_request) do |processed_request|
-          Makit::Logging.debug("Makit::Commands::Runner.execute executing strategy")
-          result = @strategy.execute(processed_request)
-          Makit::Logging.debug("Makit::Commands::Runner.execute strategy returned result")
-          result
-        end
-        Makit::Logging.debug("Makit::Commands::Runner.execute returning result")
-        Makit::Logging.debug("Makit::Commands::Runner request.exit_on_failure?: #{request.exit_on_failure?}")
-        # stderr often contains warnings that we don't want to exit on
-        if request.exit_on_failure? && (result.failure?)
-          Makit::Logging.error("exiting with exit code: #{result.exit_code}")
-          exit result.exit_code
-        end
-        result
-      end
-
-      # Execute multiple command requests.
-      #
-      # @param requests [Array<Request, String, Hash>] requests to execute
-      # @return [Array<Result>] execution results
-      def execute_batch(requests)
-        # Normalize all requests
-        normalized_requests = requests.map { |req| normalize_request(req) }
-
-        # Use strategy's batch execution if available, otherwise execute individually
-        if @strategy.respond_to?(:execute_batch)
-          # Apply middleware to the entire batch
-          execute_with_middleware_batch(normalized_requests) do |processed_requests|
-            @strategy.execute_batch(processed_requests)
-          end
-        else
-          # Execute each request individually with middleware
-          normalized_requests.map { |request| execute(request) }
-        end
-      end
-
-      # Add middleware to the execution chain.
-      #
-      # @param middleware_instance [Middleware::Base] middleware to add
-      # @return [self] for method chaining
-      def add_middleware(middleware_instance)
-        validate_middleware_instance(middleware_instance)
-        @middleware << middleware_instance
-        self
-      end
-
-      # Remove middleware from the execution chain.
-      #
-      # @param middleware_class [Class] middleware class to remove
-      # @return [self] for method chaining
-      def remove_middleware(middleware_class)
-        @middleware.reject! { |m| m.is_a?(middleware_class) }
-        self
-      end
-
-      # Check if specific middleware is present.
-      #
-      # @param middleware_class [Class] middleware class to check
-      # @return [Boolean] true if middleware is present
-      def has_middleware?(middleware_class)
-        @middleware.any? { |m| m.is_a?(middleware_class) }
-      end
-
-      # Get runner configuration for debugging.
-      #
-      # @return [Hash] runner configuration
-      def config
-        {
-          middleware: @middleware.map(&:config),
-          strategy: @strategy.config,
-          options: @options,
-        }
-      end
-
-      # Get execution statistics.
-      #
-      # @return [Hash] execution statistics
-      def stats
-        @stats ||= {
-          total_executions: 0,
-          successful_executions: 0,
-          failed_executions: 0,
-          total_duration: 0.0,
-        }
-      end
-
-      private
-
-      # Execute request with middleware chain.
-      #
-      # @param request [Request] normalized request
-      # @yield [Request] yields processed request to execution
-      # @return [Result] execution result
-      def execute_with_middleware(request, &block)
-        # Build middleware chain
-        chain = build_middleware_chain(request)
-
-        # Execute chain
-        result = chain.call(request, &block)
-
-        # Log high-level success/error using the default logger
-        log_command_result(request, result)
-
-        # Update statistics
-        update_stats(result)
-
-        result
-      end
-
-      # Execute batch with middleware chain.
-      #
-      # @param requests [Array<Request>] normalized requests
-      # @yield [Array<Request>] yields processed requests to execution
-      # @return [Array<Result>] execution results
-      def execute_with_middleware_batch(requests, &block)
-        # For batch execution, apply middleware to each request individually
-        # This maintains the middleware contract while supporting batch execution
-        results = requests.map do |request|
-          execute_with_middleware(request) { |req| [req] }
-        end.flatten
-
-        # Then execute the batch
-        processed_requests = results.map(&:command).map { |cmd| Request.from_string(cmd) }
-        batch_results = block.call(processed_requests)
-
-        # Update statistics for batch
-        batch_results.each { |result| update_stats(result) }
-
-        batch_results
-      end
-
-      # Build middleware execution chain.
-      #
-      # @param request [Request] the request to process
-      # @return [Proc] middleware chain
-      def build_middleware_chain(request)
-        # Filter middleware that applies to this request
-        applicable_middleware = @middleware.select { |m| m.applicable?(request) }
-
-        # Build chain in reverse order so first middleware wraps everything
-        applicable_middleware.reverse.reduce(method(:execute_final)) do |chain, middleware|
-          ->(req) { middleware.call(req, &chain) }
-        end
-      end
-
-      # Final execution step (after all middleware).
-      #
-      # @param request [Request] processed request
-      # @return [Result] execution result
-      def execute_final(request)
-        @strategy.execute(request)
-      end
-
-      # Normalize various input types to Request objects.
-      #
-      # @param request [Request, String, Hash] request in various formats
-      # @return [Request] normalized request
-      # @raise [ArgumentError] if request cannot be normalized
-      def normalize_request(request)
-        case request
-        when Request
-          request
-        when String
-          Request.from_string(request)
-        when Hash
-          Request.from_hash(request)
-        else
-          raise ArgumentError, "Invalid request type: #{request.class}. Expected Request, String, or Hash."
-        end
-      end
-
-      # Update execution statistics.
-      #
-      # @param result [Result] execution result
-      def update_stats(result)
-        stats[:total_executions] += 1
-
-        if result.success?
-          stats[:successful_executions] += 1
-        else
-          stats[:failed_executions] += 1
-        end
-
-        stats[:total_duration] += result.duration if result.duration
-      end
-
-      # Get default middleware chain.
-      #
-      # @return [Array<Middleware::Base>] default middleware
-      def default_middleware
-        # No default middleware for now - keep it simple
-        # Subclasses or configuration can add middleware as needed
-        []
-      end
-
-      # Validate middleware array.
-      def validate_middleware
-        @middleware.each { |m| validate_middleware_instance(m) }
-      end
-
-      # Validate individual middleware instance.
-      #
-      # @param middleware [Object] middleware to validate
-      # @raise [ArgumentError] if middleware is invalid
-      def validate_middleware_instance(middleware)
-        unless middleware.respond_to?(:call)
-          raise ArgumentError, "Middleware must respond to #call: #{middleware.class}"
-        end
-
-        return if middleware.respond_to?(:applicable?)
-
-        raise ArgumentError, "Middleware must respond to #applicable?: #{middleware.class}"
-      end
-
-      # Validate execution strategy.
-      #
-      # @raise [ArgumentError] if strategy is invalid
-      def validate_strategy
-        unless @strategy.respond_to?(:execute)
-          raise ArgumentError, "Strategy must respond to #execute: #{@strategy.class}"
-        end
-
-        return if @strategy.respond_to?(:supports?)
-
-        raise ArgumentError, "Strategy must respond to #supports?: #{@strategy.class}"
-      end
-
-      # Get information about the current strategy
-      #
-      # @return [Hash] strategy information
-      def strategy_info
-        {
-          class: @strategy.class.name,
-          type: @strategy.class.name.split('::').last.downcase,
-          factory_info: Strategies::Factory.strategy_info
-        }
-      end
-
-      # Log command execution result using the default logger.
-      #
-      # @param request [Request] the executed request
-      # @param result [Result] the execution result
-      # @return [void]
-      def log_command_result(request, result)
-        # Build the full command string
-        command_string = "#{request.command} #{request.arguments&.join(" ")}".strip
-
-        # Log success or error using the default logger
-        if result.success?
-          Makit::Logging.success(command_string)
-        else
-          Makit::Logging.error(command_string)
-        end
-
-        # Log the stdout, if there is an error or stdout is enabled
-        if result.failure? || request.show_stdout?
-          if (!result.stdout.empty?)
-            # split the stdout into lines and print each line
-            result.stdout.split("\n").each do |line|
-              Makit::Logging.info(line)
-            end
-          end
-        end
-
-        # Log the stderr
-        return unless request.show_stderr? && !result.stderr.empty?
-
-        # split the stderr into lines and print each line
-        result.stderr.split("\n").each do |line|
-          Makit::Logging.info(line)
-        end
-      end
-
-      # Log runner initialization for debugging.
-      #
-      # @return [void]
-      def log_runner_initialization
-        # Only log if we have a command logger middleware
-        logger_middleware = @middleware.find { |m| m.is_a?(Middleware::CommandLogger) }
-        return unless logger_middleware
-
-        logger_middleware.logger.debug("Command runner initialized",
-                                       middleware_count: @middleware.length,
-                                       strategy: @strategy.class.name,
-                                       working_directory: Dir.pwd,
-                                       options: @options)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require_relative "request"
+require_relative "result"
+require_relative "strategies/synchronous"
+require_relative "strategies/factory"
+require_relative "middleware/base"
+require_relative "middleware/command_logger"
+
+module Makit
+  module Commands
+    # Modern command execution engine with proper separation of concerns.
+    #
+    # The Runner coordinates command execution through a middleware chain and
+    # execution strategies. It provides a clean, extensible architecture for
+    # command processing with support for caching, logging, validation, and
+    # custom execution patterns.
+    #
+    # @example Basic usage
+    #   runner = Runner.new
+    #   request = Request.from_string("git --version")
+    #   result = runner.execute(request)
+    #   puts result.stdout
+    #
+    # @example With custom middleware
+    #   runner = Runner.new(middleware: [Logger.new, Cache.new])
+    #   result = runner.execute(request)
+    #
+    # @example With custom strategy
+    #   runner = Runner.new(strategy: Strategies::Parallel.new)
+    #   results = runner.execute_batch(requests)
+    class Runner
+      # @!attribute [r] middleware
+      #   @return [Array<Middleware::Base>] middleware chain
+      # @!attribute [r] strategy
+      #   @return [Strategies::Base] execution strategy
+      attr_reader :middleware, :strategy
+
+      # Get the default configured runner instance.
+      #
+      # @return [Runner] default runner with standard middleware
+      def self.default
+        # Recreate the runner if the log level has changed
+        current_log_level = defined?(Makit::Logging) ? Makit::Logging.current_log_level : :info
+        if @default.nil? || @last_log_level != current_log_level
+          @last_log_level = current_log_level
+          begin
+            @default = new(
+              middleware: [
+                Middleware::CommandLogger.new(
+                  log_stdout: true,
+                  log_stderr: true,
+                  log_performance: true,
+                  max_output_lines: 50,
+                ),
+              ],
+            )
+          rescue => e
+            # Fallback to basic runner if there are issues
+            @default = new
+          end
+        end
+        @default
+      end
+
+      # Initialize a new command runner.
+      #
+      # @param middleware [Array<Middleware::Base>] middleware chain
+      # @param strategy [Strategies::Base] execution strategy
+      # @param options [Hash] additional configuration
+      def initialize(middleware: nil, strategy: nil, **options)
+        @middleware = Array(middleware || default_middleware)
+        @strategy = strategy || Strategies::Factory.create(options)
+        @options = options
+
+        validate_middleware
+        validate_strategy
+
+        # Log runner initialization
+        log_runner_initialization
+      end
+
+      # Execute a single command request.
+      #
+      # @param request [Request, String, Hash] command request to execute
+      # @return [Result] execution result
+      # @raise [ArgumentError] if request is invalid
+      def execute(request)
+        Makit::Logging.debug("Makit::Commands::Runner.execute starting")
+        # Makit::Logging.debug("Executing request: #{request.to_json_pretty}")
+        # Normalize request to Request object
+        normalized_request = normalize_request(request)
+
+        # Apply middleware chain
+        Makit::Logging.debug("Makit::Commands::Runner.execute applying middleware chain")
+        result = execute_with_middleware(normalized_request) do |processed_request|
+          Makit::Logging.debug("Makit::Commands::Runner.execute executing strategy")
+          result = @strategy.execute(processed_request)
+          Makit::Logging.debug("Makit::Commands::Runner.execute strategy returned result")
+          result
+        end
+        Makit::Logging.debug("Makit::Commands::Runner.execute returning result")
+        Makit::Logging.debug("Makit::Commands::Runner request.exit_on_failure?: #{request.exit_on_failure?}")
+        # stderr often contains warnings that we don't want to exit on
+        if request.exit_on_failure? && (result.failure?)
+          Makit::Logging.error("exiting with exit code: #{result.exit_code}")
+          exit result.exit_code
+        end
+        result
+      end
+
+      # Execute multiple command requests.
+      #
+      # @param requests [Array<Request, String, Hash>] requests to execute
+      # @return [Array<Result>] execution results
+      def execute_batch(requests)
+        # Normalize all requests
+        normalized_requests = requests.map { |req| normalize_request(req) }
+
+        # Use strategy's batch execution if available, otherwise execute individually
+        if @strategy.respond_to?(:execute_batch)
+          # Apply middleware to the entire batch
+          execute_with_middleware_batch(normalized_requests) do |processed_requests|
+            @strategy.execute_batch(processed_requests)
+          end
+        else
+          # Execute each request individually with middleware
+          normalized_requests.map { |request| execute(request) }
+        end
+      end
+
+      # Add middleware to the execution chain.
+      #
+      # @param middleware_instance [Middleware::Base] middleware to add
+      # @return [self] for method chaining
+      def add_middleware(middleware_instance)
+        validate_middleware_instance(middleware_instance)
+        @middleware << middleware_instance
+        self
+      end
+
+      # Remove middleware from the execution chain.
+      #
+      # @param middleware_class [Class] middleware class to remove
+      # @return [self] for method chaining
+      def remove_middleware(middleware_class)
+        @middleware.reject! { |m| m.is_a?(middleware_class) }
+        self
+      end
+
+      # Check if specific middleware is present.
+      #
+      # @param middleware_class [Class] middleware class to check
+      # @return [Boolean] true if middleware is present
+      def has_middleware?(middleware_class)
+        @middleware.any? { |m| m.is_a?(middleware_class) }
+      end
+
+      # Get runner configuration for debugging.
+      #
+      # @return [Hash] runner configuration
+      def config
+        {
+          middleware: @middleware.map(&:config),
+          strategy: @strategy.config,
+          options: @options,
+        }
+      end
+
+      # Get execution statistics.
+      #
+      # @return [Hash] execution statistics
+      def stats
+        @stats ||= {
+          total_executions: 0,
+          successful_executions: 0,
+          failed_executions: 0,
+          total_duration: 0.0,
+        }
+      end
+
+      private
+
+      # Execute request with middleware chain.
+      #
+      # @param request [Request] normalized request
+      # @yield [Request] yields processed request to execution
+      # @return [Result] execution result
+      def execute_with_middleware(request, &block)
+        # Build middleware chain
+        chain = build_middleware_chain(request)
+
+        # Execute chain
+        result = chain.call(request, &block)
+
+        # Log high-level success/error using the default logger
+        log_command_result(request, result)
+
+        # Update statistics
+        update_stats(result)
+
+        result
+      end
+
+      # Execute batch with middleware chain.
+      #
+      # @param requests [Array<Request>] normalized requests
+      # @yield [Array<Request>] yields processed requests to execution
+      # @return [Array<Result>] execution results
+      def execute_with_middleware_batch(requests, &block)
+        # For batch execution, apply middleware to each request individually
+        # This maintains the middleware contract while supporting batch execution
+        results = requests.map do |request|
+          execute_with_middleware(request) { |req| [req] }
+        end.flatten
+
+        # Then execute the batch
+        processed_requests = results.map(&:command).map { |cmd| Request.from_string(cmd) }
+        batch_results = block.call(processed_requests)
+
+        # Update statistics for batch
+        batch_results.each { |result| update_stats(result) }
+
+        batch_results
+      end
+
+      # Build middleware execution chain.
+      #
+      # @param request [Request] the request to process
+      # @return [Proc] middleware chain
+      def build_middleware_chain(request)
+        # Filter middleware that applies to this request
+        applicable_middleware = @middleware.select { |m| m.applicable?(request) }
+
+        # Build chain in reverse order so first middleware wraps everything
+        applicable_middleware.reverse.reduce(method(:execute_final)) do |chain, middleware|
+          ->(req) { middleware.call(req, &chain) }
+        end
+      end
+
+      # Final execution step (after all middleware).
+      #
+      # @param request [Request] processed request
+      # @return [Result] execution result
+      def execute_final(request)
+        @strategy.execute(request)
+      end
+
+      # Normalize various input types to Request objects.
+      #
+      # @param request [Request, String, Hash] request in various formats
+      # @return [Request] normalized request
+      # @raise [ArgumentError] if request cannot be normalized
+      def normalize_request(request)
+        case request
+        when Request
+          request
+        when String
+          Request.from_string(request)
+        when Hash
+          Request.from_hash(request)
+        else
+          raise ArgumentError, "Invalid request type: #{request.class}. Expected Request, String, or Hash."
+        end
+      end
+
+      # Update execution statistics.
+      #
+      # @param result [Result] execution result
+      def update_stats(result)
+        stats[:total_executions] += 1
+
+        if result.success?
+          stats[:successful_executions] += 1
+        else
+          stats[:failed_executions] += 1
+        end
+
+        stats[:total_duration] += result.duration if result.duration
+      end
+
+      # Get default middleware chain.
+      #
+      # @return [Array<Middleware::Base>] default middleware
+      def default_middleware
+        # No default middleware for now - keep it simple
+        # Subclasses or configuration can add middleware as needed
+        []
+      end
+
+      # Validate middleware array.
+      def validate_middleware
+        @middleware.each { |m| validate_middleware_instance(m) }
+      end
+
+      # Validate individual middleware instance.
+      #
+      # @param middleware [Object] middleware to validate
+      # @raise [ArgumentError] if middleware is invalid
+      def validate_middleware_instance(middleware)
+        unless middleware.respond_to?(:call)
+          raise ArgumentError, "Middleware must respond to #call: #{middleware.class}"
+        end
+
+        return if middleware.respond_to?(:applicable?)
+
+        raise ArgumentError, "Middleware must respond to #applicable?: #{middleware.class}"
+      end
+
+      # Validate execution strategy.
+      #
+      # @raise [ArgumentError] if strategy is invalid
+      def validate_strategy
+        unless @strategy.respond_to?(:execute)
+          raise ArgumentError, "Strategy must respond to #execute: #{@strategy.class}"
+        end
+
+        return if @strategy.respond_to?(:supports?)
+
+        raise ArgumentError, "Strategy must respond to #supports?: #{@strategy.class}"
+      end
+
+      # Get information about the current strategy
+      #
+      # @return [Hash] strategy information
+      def strategy_info
+        {
+          class: @strategy.class.name,
+          type: @strategy.class.name.split('::').last.downcase,
+          factory_info: Strategies::Factory.strategy_info
+        }
+      end
+
+      # Log command execution result using the default logger.
+      #
+      # @param request [Request] the executed request
+      # @param result [Result] the execution result
+      # @return [void]
+      def log_command_result(request, result)
+        # Build the full command string
+        command_string = "#{request.command} #{request.arguments&.join(" ")}".strip
+
+        # Log success or error using the default logger
+        if result.success?
+          Makit::Logging.success(command_string)
+        else
+          Makit::Logging.error(command_string)
+        end
+
+        # Log the stdout, if there is an error or stdout is enabled
+        if result.failure? || request.show_stdout?
+          if (!result.stdout.empty?)
+            # split the stdout into lines and print each line
+            result.stdout.split("\n").each do |line|
+              Makit::Logging.info(line)
+            end
+          end
+        end
+
+        # Log the stderr
+        return unless request.show_stderr? && !result.stderr.empty?
+
+        # split the stderr into lines and print each line
+        result.stderr.split("\n").each do |line|
+          Makit::Logging.info(line)
+        end
+      end
+
+      # Log runner initialization for debugging.
+      #
+      # @return [void]
+      def log_runner_initialization
+        # Only log if we have a command logger middleware
+        logger_middleware = @middleware.find { |m| m.is_a?(Middleware::CommandLogger) }
+        return unless logger_middleware
+
+        logger_middleware.logger.debug("Command runner initialized",
+                                       middleware_count: @middleware.length,
+                                       strategy: @strategy.class.name,
+                                       working_directory: Dir.pwd,
+                                       options: @options)
+      end
+    end
+  end
+end