makit 0.0.112 → 0.0.128

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

@@ -1,160 +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)
-          system("which #{command} > /dev/null 2>&1") ||
-            system("where #{command} > nul 2>&1") # Windows
-        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/synchronous.rb

@@ -1,134 +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 = options.fetch(:validate_commands, true)
-          @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)
-            return Result.failure(
-                     command: request.to_shell_command,
-                     error: "Command not found: #{request.command}",
-                   )
-          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].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