makit 0.0.111 → 0.0.126

data/lib/makit/commands/compatibility.rb

@@ -1,365 +0,0 @@
-# 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

data/lib/makit/commands/middleware/unified_logger.rb

@@ -1,243 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Makit
-  module Commands
-    module Middleware
-      # Unified logging middleware that consolidates all command logging functionality
-      #
-      # This middleware replaces the need for multiple separate logging middleware
-      # by providing a single, comprehensive logging solution that handles console
-      # display, file logging, and structured logging through the Makit::Logging system.
-      #
-      # @example Basic usage
-      #   logger = UnifiedLogger.new
-      #   runner = Runner.new(middleware: [logger])
-      #   result = runner.execute("git --version")
-      #
-      # @example With custom logger configuration
-      #   custom_logger = Makit::Logging::Logger.new(
-      #     sinks: [
-      #       Makit::Logging::Sinks::Console.new,
-      #       Makit::Logging::Sinks::FileSink.new(log_file: "artifacts/commands.log")
-      #     ]
-      #   )
-      #   logger = UnifiedLogger.new(logger: custom_logger)
-      #   runner = Runner.new(middleware: [logger])
-      class UnifiedLogger < Base
-        # @!attribute [r] logger
-        #   @return [Makit::Logging::Logger] the logging instance
-        attr_reader :logger
-
-        # Initialize unified logging middleware.
-        #
-        # @param logger [Makit::Logging::Logger, nil] custom logger instance
-        # @param log_to_console [Boolean] whether to log to console
-        # @param log_to_file [Boolean] whether to log to file
-        # @param log_performance [Boolean] whether to log performance metrics
-        # @param log_output [Boolean] whether to log command output
-        def initialize(logger: nil, log_to_console: true, log_to_file: true, log_performance: true, log_output: false)
-          @logger = logger || create_default_logger(log_to_console, log_to_file)
-          @log_performance = log_performance
-          @log_output = log_output
-        end
-
-        # Execute command with unified logging.
-        #
-        # @param request [Request] command request to execute
-        # @yield [Request] yields request to next middleware
-        # @return [Result] execution result
-        def call(request, &block)
-          command_id = generate_command_id
-          start_time = Time.now
-
-          # Log command start
-          log_command_start(request, command_id)
-
-          begin
-            # Execute the command
-            result = block.call(request)
-            duration = Time.now - start_time
-
-            # Log command completion
-            log_command_completion(request, result, duration, command_id)
-
-            result
-          rescue => error
-            duration = Time.now - start_time
-
-            # Log command error
-            log_command_error(request, error, duration, command_id)
-
-            raise
-          end
-        end
-
-        # Check if this middleware applies to the given request.
-        #
-        # @param request [Request] command request
-        # @return [Boolean] true if middleware applies
-        def applicable?(request)
-          true
-        end
-
-        # Get middleware configuration.
-        #
-        # @return [Hash] middleware configuration
-        def config
-          {
-            name: "UnifiedLogger",
-            description: "Unified logging for command execution with console and file output",
-            log_performance: @log_performance,
-            log_output: @log_output,
-            logger_class: @logger.class.name,
-          }
-        end
-
-        private
-
-        # Create default logger with console and file output
-        #
-        # @param log_to_console [Boolean] whether to log to console
-        # @param log_to_file [Boolean] whether to log to file
-        # @return [Makit::Logging::Logger] configured logger
-        def create_default_logger(log_to_console, log_to_file)
-          sinks = []
-
-          if log_to_console
-            sinks << Makit::Logging::Sinks::Console.new
-          end
-
-          if log_to_file
-            sinks << Makit::Logging::Sinks::FileSink.new(
-              log_file: "artifacts/commands.log",
-              formatter: :json,
-              include_metadata: true,
-            )
-          end
-
-          Makit::Logging::Logger.new(sinks: sinks)
-        end
-
-        # Log command execution start.
-        #
-        # @param request [Request] command request
-        # @param command_id [String] unique command identifier
-        def log_command_start(request, command_id)
-          @logger.info("Command execution started", {
-            command_id: command_id,
-            command: request.command,
-            arguments: request.arguments,
-            working_directory: request.directory,
-            timeout: request.timeout,
-            environment: request.environment&.keys || [],
-          })
-        end
-
-        # Log command execution completion.
-        #
-        # @param request [Request] command request
-        # @param result [Result] execution result
-        # @param duration [Float] execution duration
-        # @param command_id [String] unique command identifier
-        def log_command_completion(request, result, duration, command_id)
-          log_data = {
-            command_id: command_id,
-            command: request.command,
-            arguments: request.arguments,
-            success: result.success?,
-            exit_code: result.exit_code,
-            duration: duration,
-            working_directory: request.directory,
-          }
-
-          # Add performance metrics if enabled
-          if @log_performance
-            log_data.merge!(
-              memory_usage: get_memory_usage,
-              timestamp: Time.now.iso8601,
-            )
-          end
-
-          # Add output if enabled and present
-          if @log_output
-            log_data[:stdout_lines] = result.stdout&.split("\n")&.length || 0
-            log_data[:stderr_lines] = result.stderr&.split("\n")&.length || 0
-            log_data[:stdout] = result.stdout if result.stdout && !result.stdout.empty?
-            log_data[:stderr] = result.stderr if result.stderr && !result.stderr.empty?
-          end
-
-          # Log at appropriate level based on success
-          if result.success?
-            @logger.success("Command completed successfully", log_data)
-          else
-            @logger.error("Command completed with errors", log_data)
-          end
-
-          # Log slow commands
-          if @log_performance && duration > 1.0
-            @logger.warn("Slow command detected",
-                         command_id: command_id,
-                         command: request.command,
-                         duration: duration)
-          end
-        end
-
-        # Log command execution error.
-        #
-        # @param request [Request] command request
-        # @param error [Exception] execution error
-        # @param duration [Float] execution duration
-        # @param command_id [String] unique command identifier
-        def log_command_error(request, error, duration, command_id)
-          @logger.error("Command execution failed", {
-            command_id: command_id,
-            command: request.command,
-            arguments: request.arguments,
-            working_directory: request.directory,
-            error_class: error.class.name,
-            error_message: error.message,
-            duration: duration,
-            backtrace: error.backtrace&.first(5),
-          })
-        end
-
-        # Generate a unique command identifier.
-        #
-        # @return [String] unique command ID
-        def generate_command_id
-          "#{::Process.pid}-#{Time.now.to_f}-#{rand(1000)}"
-        end
-
-        # Get current memory usage (if available).
-        #
-        # @return [String, nil] memory usage string or nil if unavailable
-        def get_memory_usage
-          # Try to get memory usage on different platforms
-          if RUBY_PLATFORM.match?(/mswin|mingw/)
-            # Windows - try to get memory usage
-            begin
-              "Unknown"
-            rescue
-              nil
-            end
-          else
-            # Unix-like systems
-            begin
-              # Try to get memory usage from /proc/self/status
-              if File.exist?("/proc/self/status")
-                status = File.read("/proc/self/status")
-                if match = status.match(/VmRSS:\s+(\d+)\s+kB/)
-                  "#{match[1].to_i / 1024}MB"
-                end
-              end
-            rescue
-              nil
-            end
-          end
-        end
-      end
-    end
-  end
-end