makit 0.0.111 → 0.0.126

data/lib/makit/command_runner.rb

@@ -1,463 +0,0 @@
-# frozen_string_literal: true
-
-require "English"
-require "open3"
-require "socket"
-require "etc"
-require "logger"
-require_relative "mp/command_request.mp"
-
-# This module provides classes for the Makit gem.
-module Makit
-  # This class provide methods running commands.
-  #
-  # @deprecated Use Commands::Runner instead. This class will be removed in a future version.
-  # @see Commands::Runner for the modern command execution API
-  class CommandRunner
-    attr_accessor :show_output_on_success, :log_to_artifacts, :commands, :debug, :default_modified
-
-    def initialize
-      warn_deprecation("CommandRunner is deprecated. Use Commands::Runner instead.")
-      @show_output_on_success = false
-      @log_to_artifacts = false
-      @commands = []
-      @debug = false
-      git_file_infos = Makit::Git::Repository.get_file_infos
-      @default_modified = if git_file_infos.length.positive?
-          git_file_infos.first.mtime # Makit::GIT_FILE_INFOS.first.mtime
-        else
-          Time.now
-        end
-    end
-
-    # search command history for matching commands
-    def search(query)
-      results = []
-      commands.each do |command|
-        keywords = []
-        keywords << command.name.downcase
-        command.arguments.each do |argument|
-          keywords << argument.downcase unless keywords.include?(argument.downcase)
-        end
-        # output is bytes, so convert to UTF 8 string
-        # output_bytes = command.output.clone
-        # output = command.output.clone.force_encoding('UTF-8')
-        # error_bytes = command.error.clone
-        # error = error_bytes.force_encoding('UTF-8')
-        # output.split(" ").each {|word|
-        #  if(word.length > 3)
-        #    keywords << word.downcase unless keywords.include?(word.downcase)
-        #  end
-        # }
-        # error.split(" ").each { |word|
-        #  if(word.length > 3)
-        #    keywords << word.downcase unless keywords.include?(word.downcase)
-        #  end
-        # }
-        matchCount = 0
-        terms = query.downcase.split
-        terms.each do |term|
-          matchCount += 1 if keywords.include?(term)
-        end
-        results << command if matchCount == terms.length
-      end
-      results
-    end
-
-    def get_cache_filename(command)
-      int_hash = Digest::SHA256.hexdigest("#{command.name}.#{command.arguments.join(" ")}")
-      hash_string = int_hash.to_s
-      cache_filename = Makit::Directories::PROJECT_ARTIFACTS +
-                       "/commands/cache/#{hash_string}.pb"
-      # create the directory if it does not already exist
-      FileUtils.mkdir_p(File.dirname(cache_filename))
-      cache_filename
-    end
-
-    # @deprecated Use Commands::Runner with caching middleware instead
-    def cache_run(command_request)
-      warn_deprecation("CommandRunner#cache_run is deprecated. Use Commands::Runner with caching middleware instead.")
-      cache_run(command_request, @default_modified)
-    end
-
-    # if there is a matching cached command result, that then the specified timestamp,
-    # then return the cached result
-    # otherwise run the command and save the result to a cache file
-    # then return the result
-    def cache_run(command_request, timestamp)
-      raise "Invalid command_request" unless command_request.is_a? Makit::V1::CommandRequest
-
-      cache_filename = get_cache_filename(command_request)
-
-      # Check if timestamp is a valid Time object
-      raise ArgumentError, "timestamp must be a Time object, got #{timestamp.class}" unless timestamp.is_a?(Time)
-
-      if debug
-        Makit::Logging.debug("Cache run debug info", {
-          timestamp: Makit::Humanize.get_humanized_timestamp(timestamp),
-          command: command_request.name,
-          arguments: command_request.arguments.join(" "),
-          cache_filename: cache_filename,
-        })
-      end
-      # cache_filename = Makit::Directories::PROJECT_ARTIFACTS + "/commands/#{command_request.name}.#{command_request.arguments.join("_")}.#{timestamp.seconds}.pb"
-      if File.exist?(cache_filename)
-        cache_timestamp = File.mtime(cache_filename)
-        Makit::Logging.debug("Cache timestamp", {
-          cache_timestamp: Makit::Humanize.get_humanized_timestamp(cache_timestamp),
-        }) if debug
-        # puts "cache file date: #{File.mtime(cache_filename)}"
-        if File.mtime(cache_filename) > timestamp
-          Makit::Logging.info("Using cached command result", {
-            command: command_request.name,
-            arguments: command_request.arguments,
-            cache_filename: cache_filename,
-            cache_timestamp: Makit::Humanize.get_humanized_timestamp(cache_timestamp),
-          })
-
-          command = Makit::Serializer.open(cache_filename, Makit::V1::Command)
-          show_cached_command(command)
-          abort "cached command failed: #{command.name} #{command.arguments.join(" ")}" if command.exit_code != 0
-          return command
-        else
-          Makit::Logging.debug("Cache file is older than timestamp", {
-            cache_filename: cache_filename,
-            timestamp: Makit::Humanize.get_humanized_timestamp(timestamp),
-          }) if debug
-          File.delete(cache_filename)
-        end
-      end
-
-      command = run(command_request)
-      # make sure the cache directory exists
-      FileUtils.mkdir_p(File.dirname(cache_filename))
-
-      Makit::Logging.info("Saving command to cache", {
-        command: command.name,
-        arguments: command.arguments,
-        cache_filename: cache_filename,
-        success: command.exit_code.zero?,
-      })
-
-      Makit::Serializer.save_as(cache_filename, command)
-      commands.push(command)
-      command
-    end
-
-    def show_command(command)
-      if command.exit_code.zero?
-        Makit::Logging.success("Command completed", {
-          command: command.name,
-          arguments: command.arguments,
-          duration: command.duration&.seconds || 0,
-          output: show_output_on_success ? command.output : nil,
-        })
-      else
-        Makit::Logging.error("Command failed", {
-          command: command.name,
-          arguments: command.arguments,
-          exit_code: command.exit_code,
-          directory: command.directory,
-          duration: command.duration&.seconds || 0,
-          output: command.output.length.positive? ? command.output : nil,
-          error: command.error.length.positive? ? command.error : nil,
-        })
-      end
-    end
-
-    def show_cached_command(command)
-      if command.exit_code.zero?
-        Makit::Logging.info("Cached command completed", {
-          command: command.name,
-          arguments: command.arguments,
-          duration: command.duration&.seconds || 0,
-          cached: true,
-          output: show_output_on_success ? command.output : nil,
-        })
-      else
-        Makit::Logging.warn("Cached command failed", {
-          command: command.name,
-          arguments: command.arguments,
-          exit_code: command.exit_code,
-          directory: command.directory,
-          duration: command.duration&.seconds || 0,
-          cached: true,
-          output: command.output.length.positive? ? command.output : nil,
-          error: command.error.length.positive? ? command.error : nil,
-        })
-      end
-    end
-
-    # Run a command and return a Makit::V1::Command.
-    # @deprecated Use Commands::Runner#execute instead
-    def run(command_request)
-      warn_deprecation("CommandRunner#run is deprecated. Use Commands::Runner#execute instead.")
-      raise "Invalid command_request" unless command_request.is_a? Makit::V1::CommandRequest
-
-      # Log command start
-      Makit::Logging.info("Starting command execution", {
-        command: command_request.name,
-        arguments: command_request.arguments,
-        directory: command_request.directory,
-      })
-
-      command = execute(command_request)
-
-      log_to_artifacts(command) if @log_to_artifacts
-      show_command(command)
-      exit 1 if (command.exit_code != 0) && command_request.exit_on_error
-      commands.push(command)
-      command
-    end
-
-    def log_to_artifacts(command)
-      log_filename = get_cache_filename(command)
-      Makit::Serializer.save_as(log_filename, command)
-    end
-
-    # Run a command and return a Makit::V1::Command.
-    # @deprecated Use Commands::Runner#execute with exit_on_error: false instead
-    def try(args)
-      warn_deprecation("CommandRunner#try is deprecated. Use Commands::Runner#execute with exit_on_error: false instead.")
-      request = parse_command_request(args)
-      request.exit_on_error = false
-      run(request)
-    end
-
-    def cache_try(command_request)
-      cache_try(command_request, @default_modified)
-    end
-
-    def cache_try(command_request, timestamp)
-      command_request.exit_on_error = false
-      cache_run(command_request, timestamp)
-    end
-
-    # Show the output of a command and return a Makit::V1::Command.
-    # @deprecated Use Commands::Runner#execute with show_output: true instead
-    def show(args)
-      warn_deprecation("CommandRunner#show is deprecated. Use Commands::Runner#execute with show_output: true instead.")
-      request = parse_args(args)
-      command = execute(request)
-
-      # Log command execution with structured data
-      if command.exit_code.zero?
-        Makit::Logging.success("Command executed successfully", {
-          command: command.name,
-          arguments: command.arguments,
-          duration: command.duration&.seconds || 0,
-          output: command.output,
-        })
-      else
-        Makit::Logging.error("Command execution failed", {
-          command: command.name,
-          arguments: command.arguments,
-          exit_code: command.exit_code,
-          duration: command.duration&.seconds || 0,
-          output: command.output,
-          error: command.error,
-        })
-        exit(command.exit_code) if command.exit_code != 0
-      end
-      command
-    end
-
-    # Parse and return a Makit::V1::CommandRequest.
-    def parse_command_request(source)
-      return Makit::V1::CommandRequest.new(source) if source.is_a? Hash
-      return source if source.is_a? Makit::V1::CommandRequest
-      return parse_args(source) if source.is_a? String
-
-      raise "Invalid source" unless source.is_a? Makit::V1::CommandRequest
-    end
-
-    def parse_command_request_from_hash(hash)
-      raise "Invalid hash" unless hash.is_a? Hash
-
-      Makit::V1::CommandRequest.new(hash)
-    end
-
-    def parse_command_request_from_string(source)
-      raise "Invalid source" unless source.is_a? String
-
-      words = source.split
-      {
-        name: words.shift,
-        arguments: words,
-        exit_on_error: true,
-      }
-    end
-
-    # Parse the command line arguments into a Makit::V1::CommandRequest.
-    def parse_args(args)
-      # raise "No command specified" if args.empty?
-      if args.is_a? Makit::V1::CommandRequest
-        args
-      elsif args.is_a? String
-        args = args.split
-        hash = if args.length == 1
-            {
-              name: args[0],
-              arguments: [],
-              exit_on_error: true,
-            }
-          else
-            {
-              name: args.shift,
-              arguments: args,
-              exit_on_error: true,
-            }
-          end
-        Makit::V1::CommandRequest.new(hash)
-      else
-        Makit::V1::CommandRequest.new(args)
-      end
-    end
-
-    def get_path_name(name)
-      # replace all characters that a not valid in a filename with an underscore
-      name.gsub(/[^0-9a-z]/i, "_")
-    end
-
-    # Given a Makit::V1::CommandRequest, execute the command and return a Makit::V1::Command.
-    def execute(args)
-      command_request = parse_args(args)
-      command_request.directory = Dir.pwd if command_request.directory.nil?
-      command_request.directory = Dir.pwd if command_request.directory.empty?
-      result = Makit::V1::Command.new(name: command_request.name)
-      command_request.arguments.each do |arg|
-        result.arguments.push(arg)
-      end
-      command = "#{command_request.name} #{command_request.arguments.join(" ")}"
-      result.directory = command_request.directory
-      start = Time.now
-      filename_friendly_timestamp = Time.now.strftime("%Y.%m.%d_%H%M%S")
-      File.join(Makit::Directories::LOG, "#{filename_friendly_timestamp}.log")
-
-      # assign a directory variable to the current working directory, if not specified,
-      # otherwise assign the specified directory
-      command_request.directory = Dir.pwd if command_request.directory.nil?
-      command_request.directory = Dir.pwd if command_request.directory.empty?
-      raise "Invalid directory" unless Dir.exist?(command_request.directory)
-
-      result.started_at = Google::Protobuf::Timestamp.new(seconds: start.to_i, nanos: start.nsec.to_i)
-      ############# execute the command
-      (output, error, exit_code) = execute_command(command, command_request.directory, command_request.timeout)
-      result.output = output.dup.force_encoding("ASCII-8BIT")
-      result.error = error.dup.force_encoding("ASCII-8BIT")
-      result.exit_code = exit_code.nil? ? 0 : exit_code
-
-      elapsed_time = Time.now - start
-      seconds = elapsed_time.to_i
-      nanos = ((elapsed_time - seconds) * 1_000_000_000).to_i
-
-      result.duration = Google::Protobuf::Duration.new(seconds: seconds, nanos: nanos)
-
-      result
-    end
-
-    # pure function to execute a command
-    # returns (stdout, stderr, exit_code) or raise an exception
-    def execute_command(command, directory, timeout)
-      original_directory = Dir.pwd
-      begin
-        output = nil
-        error = nil
-        process_status = nil
-        Dir.chdir(directory) do
-          output, error, process_status = Open3.capture3(command)
-        end
-        [output, error, process_status.exitstatus]
-      rescue StandardError => e
-        # restore the original working directory
-        Dir.chdir(original_directory)
-        message_parts = []
-        message_parts << "failed to execute #{command}"
-        message_parts << "directory: #{directory}"
-        message_parts << "timeout: #{timeout}" unless timeout.nil?
-        message_parts << "error: #{e.message}"
-        message = "#{message_parts.join("\n")}\n"
-        ["", message, 1]
-        # raise Makit::Error, message
-      end
-    end
-
-    def execute_command_request(command_request)
-      # if the command_request is not a Makit::V1::CommandRequest, raise an error
-      raise "Invalid command_request" unless command_request.is_a? Makit::V1::CommandRequest
-
-      args = command_request.arguments.map do |arg|
-        arg
-      end
-      Makit::V1::Command.new({
-                               name: command_request.name,
-                               arguments: args,
-                               started_at: Google::Protobuf::Timestamp.new({ seconds: Time.now.to_i,
-                                                                             nanos: Time.now.nsec }),
-                             })
-
-      begin
-      rescue StandardError
-      end
-    end
-
-    def indent_string(input_string, indent_spaces)
-      indentation = " " * indent_spaces
-      input_string.lines.map { |line| indentation + line }.join
-    end
-
-    def self.get_command_summary(command)
-      symbol = Makit::Symbols.warning
-      symbol = Makit::Symbols.checkmark if !command.exit_code.nil? && command.exit_code.zero?
-      symbol = Makit::Symbols.error if command.exit_code != 0
-      summary = "#{symbol} #{command.name.colorize(:yellow)} #{command.arguments.join(" ")}"
-
-      summary = summary.to_lines(80, command.name.length + 3) if summary.length > 80
-
-      summary
-    end
-
-    def log_rake_commands
-      dir = File.join(Makit::Directories::PROJECT_ARTIFACTS, "commands")
-      FileUtils.mkdir_p(dir)
-
-      # open a text file to write to
-      File.open(File.join(dir, "rake.commands.txt"), "w") do |file|
-        # rake_commands = commands.select { |command| command.name == "rake" }
-        commands.each do |command|
-          file.puts " #{Makit::CommandRunner.get_command_summary(command).strip_color_codes}"
-          file.puts "   start time: #{command.started_at}"
-          file.puts command.output.strip_color_codes unless command.output.strip_color_codes.strip.empty?
-          file.puts command.error.strip_color_codes unless command.error.strip_color_codes.strip.empty?
-          file.puts " "
-        end
-      end
-    end
-
-    def log_slowest_commands
-      dir = File.join(Makit::Directories::PROJECT_ARTIFACTS, "commands")
-      FileUtils.mkdir_p(dir)
-
-      # open a text file to write to
-      File.open(File.join(dir, "slow.commands.txt"), "w") do |file|
-        Makit::RUNNER.commands.sort_by do |command|
-          (command.duration.seconds + (command.duration.nanos / 1_000_000_000.0))
-        end.reverse.first(5).each do |command|
-          # Convert to float representation
-          command.duration.seconds + (command.duration.nanos / 1_000_000_000.0)
-          # puts "  #{command.name} took #{duration_in_float} seconds"
-          file.puts " #{Makit::CommandRunner.get_command_summary(command).strip_color_codes} (#{command.duration.seconds} seconds)"
-        end
-      end
-    end
-
-    private
-
-    # Helper method to emit deprecation warnings
-    #
-    # @param message [String] deprecation message
-    def warn_deprecation(message)
-      warn "[DEPRECATED] #{message} (called from #{caller(1, 1).first})"
-    end
-  end
-end