makit 0.0.98 → 0.0.111

data/lib/makit/commands/compatibility.rb

@@ -0,0 +1,365 @@
+# frozen_string_literal: true
+
+require "ostruct"
+require "fileutils"
+require_relative "runner"
+require_relative "request"
+require_relative "result"
+
+module Makit
+  module Commands
+    # Compatibility layer that provides legacy interface methods for the new Commands::Runner
+    #
+    # This class bridges the gap between the old CommandRunner interface and the new
+    # Commands::Runner architecture, allowing existing code to work without modification
+    # while benefiting from the improved architecture.
+    class Compatibility
+      # @!attribute [r] runner
+      #   @return [Runner] the underlying Commands::Runner instance
+      attr_reader :runner
+
+      # Initialize compatibility layer
+      #
+      # @param runner [Runner] the Commands::Runner instance to wrap
+      def initialize(runner = nil)
+        @runner = runner || create_runner_with_caching
+      end
+
+      # Parse command request from various input types (legacy interface)
+      #
+      # @param source [String, Hash, Request] command source
+      # @return [Request] normalized request
+      def parse_command_request(source)
+        case source
+        when String
+          Request.from_string(source)
+        when Hash
+          Request.from_hash(source)
+        when Request
+          source
+        when Makit::V1::CommandRequest
+          # Convert legacy CommandRequest to new Request
+          Request.new(
+            command: source.name,
+            arguments: source.arguments.to_a,
+            directory: source.directory,
+            timeout: source.timeout,
+            environment: {},
+            metadata: { legacy: true },
+          )
+        else
+          raise ArgumentError, "Invalid source type: #{source.class}"
+        end
+      end
+
+      # Parse arguments (legacy interface)
+      #
+      # @param args [String, Array, Hash, Request] arguments to parse
+      # @return [Request] parsed request
+      def parse_args(args)
+        parse_command_request(args)
+      end
+
+      # Execute command (legacy run interface)
+      #
+      # @param request_or_string [Request, String, Hash] command to run
+      # @return [Result] execution result converted to legacy format
+      def run(request_or_string)
+        request = parse_command_request(request_or_string)
+        result = @runner.execute(request)
+        # Store directory in result metadata for legacy compatibility
+        result.metadata[:directory] = request.directory
+        convert_to_legacy_command(result)
+      end
+
+      # Execute command with caching (legacy cache_run interface)
+      #
+      # @param request_or_string [Request, String, Hash] command to run
+      # @param timestamp [Time, nil] cache timestamp
+      # @return [Result] execution result converted to legacy format
+      def cache_run(request_or_string, timestamp = nil)
+        request = parse_command_request(request_or_string)
+
+        # Add cache metadata
+        cache_key = generate_cache_key(request)
+        request.metadata[:cache_key] = cache_key
+        request.metadata[:cache_timestamp] = timestamp || default_timestamp
+
+        # Execute with caching middleware
+        result = @runner.execute(request)
+        # Store directory in result metadata for legacy compatibility
+        result.metadata[:directory] = request.directory
+        convert_to_legacy_command(result)
+      end
+
+      # Execute command with caching without raising on error (legacy cache_try interface)
+      #
+      # @param request_or_string [Request, String, Hash] command to try
+      # @param timestamp [Time, nil] cache timestamp
+      # @return [Result] execution result converted to legacy format
+      def cache_try(request_or_string, timestamp = nil)
+        request = parse_command_request(request_or_string)
+        request.metadata[:exit_on_error] = false
+
+        # Add cache metadata
+        cache_key = generate_cache_key(request)
+        request.metadata[:cache_key] = cache_key
+        request.metadata[:cache_timestamp] = timestamp || default_timestamp
+
+        # Execute with caching middleware
+        result = @runner.execute(request)
+        # Store directory in result metadata for legacy compatibility
+        result.metadata[:directory] = request.directory
+        convert_to_legacy_command(result)
+      end
+
+      # Execute command without raising on error (legacy try interface)
+      #
+      # @param request_or_string [Request, String, Hash] command to try
+      # @return [Result] execution result converted to legacy format
+      def try(request_or_string)
+        request = parse_command_request(request_or_string)
+        request.metadata[:exit_on_error] = false
+
+        result = @runner.execute(request)
+        # Store directory in result metadata for legacy compatibility
+        result.metadata[:directory] = request.directory
+        convert_to_legacy_command(result)
+      end
+
+      # Show command information (legacy show interface)
+      #
+      # @param request_or_string [Request, String, Hash] command to show
+      # @return [Result] execution result converted to legacy format
+      def show(request_or_string)
+        request = parse_command_request(request_or_string)
+        request.metadata[:show_output] = true
+
+        result = @runner.execute(request)
+        # Store directory in result metadata for legacy compatibility
+        result.metadata[:directory] = request.directory
+        show_command(convert_to_legacy_command(result))
+        convert_to_legacy_command(result)
+      end
+
+      # Search command history for matching commands (legacy interface)
+      #
+      # @param query [String] search query
+      # @return [Array<Object>] matching command results
+      def search(query)
+        # For now, return empty array since we don't have command history in new architecture
+        # This could be enhanced with a command history middleware
+        []
+      end
+
+      # Get cache filename for a command (legacy interface)
+      #
+      # @param command [Object] command object
+      # @return [String] cache filename
+      def get_cache_filename(command)
+        require "digest"
+        if command.respond_to?(:name) && command.respond_to?(:arguments)
+          content = "#{command.name} #{command.arguments.join(" ")}"
+        else
+          content = command.to_s
+        end
+        hash = Digest::SHA256.hexdigest(content)
+        cache_dir = File.join(Makit::Directories::PROJECT_ARTIFACTS, "commands", "cache")
+        FileUtils.mkdir_p(cache_dir)
+        File.join(cache_dir, "#{hash}.pb")
+      end
+
+      # Log rake commands to file (legacy interface)
+      #
+      # @return [void]
+      def log_rake_commands
+        dir = File.join(Makit::Directories::PROJECT_ARTIFACTS, "commands")
+        FileUtils.mkdir_p(dir)
+
+        # For now, create empty file since we don't have command history
+        # This could be enhanced with a command history middleware
+        File.open(File.join(dir, "rake.commands.txt"), "w") do |file|
+          file.puts "# No command history available in new architecture"
+          file.puts "# This functionality will be restored with command history middleware"
+        end
+      end
+
+      # Log slowest commands to file (legacy interface)
+      #
+      # @return [void]
+      def log_slowest_commands
+        dir = File.join(Makit::Directories::PROJECT_ARTIFACTS, "commands")
+        FileUtils.mkdir_p(dir)
+
+        # For now, create empty file since we don't have command history
+        # This could be enhanced with a command history middleware
+        File.open(File.join(dir, "slow.commands.txt"), "w") do |file|
+          file.puts "# No command history available in new architecture"
+          file.puts "# This functionality will be restored with command history middleware"
+        end
+      end
+
+      # Display command summary (legacy show_command interface)
+      #
+      # @param command [Makit::V1::Command, Result] command result to display
+      def show_command(command)
+        # Convert new Result to legacy format if needed
+        legacy_command = command.is_a?(Result) ? convert_to_legacy_command(command) : command
+
+        if legacy_command.exit_code.zero?
+          puts get_command_summary(legacy_command) + " (#{legacy_command.duration&.seconds || 0} seconds)".colorize(:cyan)
+          puts indent_string(legacy_command.output, 2).colorize(:default) if should_show_output_on_success?
+        else
+          puts get_command_summary(legacy_command) + " (exit code #{legacy_command.exit_code})".colorize(:default)
+          puts "  directory: #{legacy_command.directory}\n"
+          puts "  duration: #{legacy_command.duration&.seconds || 0} seconds\n"
+          puts indent_string(legacy_command.output, 2) if legacy_command.output&.length&.positive?
+          puts indent_string(legacy_command.error, 2) if legacy_command.error&.length&.positive?
+        end
+      end
+
+      private
+
+      # Create a runner with caching middleware
+      #
+      # @return [Runner] runner with caching middleware
+      def create_runner_with_caching
+        require_relative "middleware/cache"
+
+        Runner.new(
+          middleware: [
+            Middleware::Cache.new,
+            Middleware::CommandLogger.new(
+              log_stdout: true,
+              log_stderr: true,
+              log_performance: true,
+              max_output_lines: 50,
+            ),
+          ],
+        )
+      end
+
+      # Convert new Result to legacy Makit::V1::Command format
+      #
+      # @param result [Result] result to convert
+      # @return [Makit::V1::Command] legacy command object
+      def convert_to_legacy_command(result)
+        # Create a legacy command object that duck-types with Makit::V1::Command
+        legacy_command = OpenStruct.new
+        legacy_command.name = result.command.split.first
+        legacy_command.arguments = result.command.split[1..] || []
+        # Get directory from metadata if available, otherwise use current directory
+        legacy_command.directory = result.metadata[:directory] || Dir.pwd
+        legacy_command.exit_code = result.exit_code
+        legacy_command.output = result.stdout
+        legacy_command.error = result.stderr
+        legacy_command.started_at = convert_time_to_protobuf_timestamp(result.started_at)
+        legacy_command.duration = convert_duration_to_protobuf(result.duration)
+
+        # Add success? method for compatibility
+        def legacy_command.success?
+          exit_code.zero?
+        end
+
+        legacy_command
+      end
+
+      # Generate cache key for a request
+      #
+      # @param request [Request] request to generate key for
+      # @return [String] cache key
+      def generate_cache_key(request)
+        require "digest"
+        content = "#{request.command} #{request.arguments.join(" ")}"
+        Digest::SHA256.hexdigest(content)
+      end
+
+      # Get default timestamp for caching
+      #
+      # @return [Time] default timestamp
+      def default_timestamp
+        if defined?(Makit::GIT_FILE_INFOS) && Makit::GIT_FILE_INFOS.any?
+          Makit::GIT_FILE_INFOS.first.mtime
+        else
+          Time.now
+        end
+      end
+
+      # Get command summary string (legacy interface)
+      #
+      # @param command [Object] command object
+      # @return [String] command summary
+      def get_command_summary(command)
+        symbol = "⚠️" # warning by default
+        symbol = "✓" if command.exit_code&.zero?
+        symbol = "✗" if command.exit_code != 0
+
+        summary = "#{symbol} #{command.name} #{command.arguments.join(" ")}"
+
+        # Apply line wrapping if available
+        if summary.respond_to?(:to_lines) && summary.length > 80
+          summary.to_lines(80, command.name.length + 3)
+        else
+          summary
+        end
+      end
+
+      # Indent string helper
+      #
+      # @param input_string [String] string to indent
+      # @param indent_spaces [Integer] number of spaces to indent
+      # @return [String] indented string
+      def indent_string(input_string, indent_spaces)
+        return "" unless input_string
+
+        indentation = " " * indent_spaces
+        input_string.lines.map { |line| indentation + line }.join
+      end
+
+      # Check if output should be shown on success
+      #
+      # @return [Boolean] true if output should be shown
+      def should_show_output_on_success?
+        # Check if the legacy runner has this setting
+        if defined?(Makit::RUNNER) && Makit::RUNNER.respond_to?(:show_output_on_success)
+          Makit::RUNNER.show_output_on_success
+        else
+          false
+        end
+      end
+
+      # Convert Time to protobuf timestamp format
+      #
+      # @param time [Time] time to convert
+      # @return [Google::Protobuf::Timestamp] protobuf timestamp
+      def convert_time_to_protobuf_timestamp(time)
+        return nil unless time
+
+        if defined?(Google::Protobuf::Timestamp)
+          Google::Protobuf::Timestamp.new(seconds: time.to_i, nanos: time.nsec)
+        else
+          # Fallback object with same interface
+          OpenStruct.new(seconds: time.to_i, nanos: time.nsec)
+        end
+      end
+
+      # Convert duration to protobuf duration format
+      #
+      # @param duration [Float] duration in seconds
+      # @return [Google::Protobuf::Duration] protobuf duration
+      def convert_duration_to_protobuf(duration)
+        return nil unless duration
+
+        seconds = duration.to_i
+        nanos = ((duration - seconds) * 1_000_000_000).to_i
+
+        if defined?(Google::Protobuf::Duration)
+          Google::Protobuf::Duration.new(seconds: seconds, nanos: nanos)
+        else
+          # Fallback object with same interface
+          OpenStruct.new(seconds: seconds, nanos: nanos)
+        end
+      end
+    end
+  end
+end