llm-shell 0.9.2 → 0.10.0

data/lib/llm/shell/internal/paint/lib/paint/constants.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Paint
+  # Clears all colors
+  NOTHING = "\033[0m"
+
+  # Number of possible colors in TRUE COLOR mode
+  TRUE_COLOR = 0xFFFFFF
+
+  # Basic colors (often, the color differs when using the bright effect)
+  # Final color will be 30 + value for foreground and 40 + value for background
+  ANSI_COLORS = {
+    :black   => 0,
+    :red     => 1,
+    :green   => 2,
+    :yellow  => 3,
+    :blue    => 4,
+    :magenta => 5,
+    :cyan    => 6,
+    :white   => 7, :gray => 7,
+    :default => 9,
+  }.freeze
+
+  ANSI_COLORS_FOREGROUND = {
+    :black   => 30,
+    :red     => 31,
+    :green   => 32,
+    :yellow  => 33,
+    :blue    => 34,
+    :magenta => 35,
+    :cyan    => 36,
+    :white   => 37, :gray => 37,
+    :default => 39,
+  }.freeze
+
+  ANSI_COLORS_BACKGROUND = {
+    :black   => 40,
+    :red     => 41,
+    :green   => 42,
+    :yellow  => 43,
+    :blue    => 44,
+    :magenta => 45,
+    :cyan    => 46,
+    :white   => 47, :gray => 47,
+    :default => 49,
+  }.freeze
+
+  # Terminal effects - most of them are not supported ;)
+  # See https://en.wikipedia.org/wiki/ANSI_escape_code
+  ANSI_EFFECTS = {
+    :reset         => 0,  :nothing         => 0,  # usually supported
+    :bright        => 1,  :bold            => 1,  # usually supported
+    :faint         => 2,
+    :italic        => 3,
+    :underline     => 4,                          # usually supported
+    :blink         => 5,  :slow_blink      => 5,
+    :rapid_blink   => 6,
+    :inverse       => 7,  :swap            => 7,  # usually supported
+    :conceal       => 8,  :hide            => 9,
+    :default_font  => 10,
+    :font0 => 10, :font1 => 11, :font2 => 12, :font3 => 13, :font4 => 14,
+    :font5 => 15, :font6 => 16, :font7 => 17, :font8 => 18, :font9 => 19,
+    :fraktur       => 20,
+    :bright_off    => 21, :bold_off        => 21, :double_underline => 21,
+    :clean         => 22,
+    :italic_off    => 23, :fraktur_off     => 23,
+    :underline_off => 24,
+    :blink_off     => 25,
+    :inverse_off   => 26, :positive        => 26,
+    :conceal_off   => 27, :show            => 27, :reveal           => 27,
+    :crossed_off   => 29, :crossed_out_off => 29,
+    :frame         => 51,
+    :encircle      => 52,
+    :overline      => 53,
+    :frame_off     => 54, :encircle_off    => 54,
+    :overline_off  => 55,
+  }.freeze
+
+  # A list of color names for standard ansi colors, needed for 16/8 color fallback mode
+  # See https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
+  RGB_COLORS_ANSI = {
+    :black   => [  0,   0,   0],
+    :red     => [205,   0,   0],
+    :green   => [  0, 205,   0],
+    :yellow  => [205, 205,   0],
+    :blue    => [  0,   0, 238],
+    :magenta => [205,   0, 205],
+    :cyan    => [  0, 205, 205],
+    :white   => [229, 229, 229], :gray => [229, 229, 229],
+  }.each { |k, v| v.freeze }.freeze
+
+  # A list of color names for standard bright ansi colors, needed for 16 color fallback mode
+  # See https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
+  RGB_COLORS_ANSI_BRIGHT = {
+    :black   => [127, 127, 127],
+    :red     => [255,   0,   0],
+    :green   => [  0, 255,   0],
+    :yellow  => [255, 255,   0],
+    :blue    => [ 92,  92, 255],
+    :magenta => [255,   0, 255],
+    :cyan    => [  0, 255, 255],
+    :white   => [255, 255, 255], :gray => [255, 255, 255],
+  }.each { |k, v| v.freeze }.freeze
+end

data/lib/llm/shell/internal/paint/lib/paint/pa.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'paint'
+
+module Kernel
+  private
+
+  # A helper method similar to puts for printing a String on STDOUT
+  # Passes all arguments to Paint.[]
+  def pa(*args)
+    puts Paint[*args]
+  end
+end

data/lib/llm/shell/internal/paint/lib/paint/rgb_colors.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Paint
+  RGB_COLORS_INDEX_FILENAME = File.dirname(__FILE__) + "/../../data/rgb_colors.marshal.gz"
+  # A list of color names, based on X11's rgb.txt
+
+  File.open(RGB_COLORS_INDEX_FILENAME, "rb") do |file|
+    serialized_data = Zlib::GzipReader.new(file).read
+    serialized_data.force_encoding Encoding::BINARY
+    RGB_COLORS = Marshal.load(serialized_data)
+  end
+end

data/lib/llm/shell/internal/paint/lib/paint/shortcuts.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative 'shortcuts_version'
+
+require 'paint'
+
+module Paint
+  # Hash for defining color/effect shortcuts
+  SHORTCUTS = {
+    # :example => {                    # would create a Paint::Example constant...
+    #   :light_red     => "\e[31;1m",  # with a method .light_red
+    # }
+  }
+  SHORTCUTS.default = {}
+
+  class << self
+    # Paint::SomeModule --> Paint::SHORTCUTS[:some_module]
+    def const_missing(mod_name)
+      # get shortcuts
+      shortcuts = SHORTCUTS[mod_name.to_s.gsub(/[A-Z]/,'_\0').downcase[1..-1].to_sym] || []
+
+      # create module
+      class_eval "module #{mod_name}; end"
+      mod = const_get(mod_name)
+
+      # define direct behaviour, class methods
+      mod.define_singleton_method :method_missing do |color_name, *args|
+        if color_code = shortcuts[color_name]
+          string = Array(args).join
+          return string if Paint.mode.zero?
+
+          if args.empty?
+            color_code
+          else
+            color_code + string + NOTHING
+          end
+        else
+          nil
+        end
+      end
+
+      mod.define_singleton_method :respond_to_missing? do |color_name, *args|
+        shortcuts.include?(color_name) || super(color_name, *args)
+      end
+
+      # define include behaviour, instance methods
+      mod.define_singleton_method :included do |_|
+        shortcuts.each{ |color_name, color_code|
+          define_method color_name do |*args|
+            string = Array(args).join
+            return string if Paint.mode.zero?
+
+            if args.empty?
+              color_code
+            else
+              color_code + string + NOTHING
+            end
+          end
+        }
+        private(*shortcuts.keys) unless shortcuts.empty?
+      end
+
+      # include variations, defined in child modules
+      mod.class_eval "module String; end"
+      string = mod.const_get(:String)
+      string.define_singleton_method :included do |_|
+        shortcuts.each{ |color_name, color_code|
+          define_method color_name do
+            if Paint.mode.zero?
+              to_s
+            else
+              color_code + to_s + NOTHING
+            end
+          end
+        }
+      end
+
+      # OK, let's take it one level further ;)
+      mod.class_eval "module Prefix; end"
+      prefix_prefix = mod.const_get(:Prefix)
+      prefix_prefix.define_singleton_method :const_missing do |prefix_name|
+        class_eval "module #{prefix_name}; end"
+        prefix = const_get(prefix_name)
+
+        prefix.define_singleton_method :included do |_|
+          define_method prefix_name.to_s.gsub(/[A-Z]/,'_\0').downcase[1..-1].to_sym do |color_name|
+            if color_code = shortcuts[color_name]
+              return to_s if Paint.mode.zero?
+              color_code + to_s + NOTHING
+            end
+          end
+        end
+
+        prefix
+      end
+
+      mod
+    end
+  end
+end

data/lib/llm/shell/internal/paint/lib/paint/shortcuts_version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Paint
+  SHORTCUTS_VERSION = '2.0.0'
+end

data/lib/llm/shell/internal/paint/lib/paint/util.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Paint
+  # Standalone helpers which add functionality you sometimes need when working with terminal colors
+  class << self
+    # Removes any color and effect strings
+    def unpaint(string)
+      string.gsub(/\e\[(?:[0-9];?)+m/, '')
+    end
+
+    # Creates a random ANSI color
+    def random(background = false)
+      (background ? 40 : 30) + rand(8)
+    end
+  end
+end

data/lib/llm/shell/internal/paint/lib/paint/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Paint
+  VERSION = "2.3.0"
+end

data/lib/llm/shell/internal/paint/lib/paint.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+require_relative 'paint/version'
+require_relative 'paint/constants'
+require_relative 'paint/util'
+
+module Paint
+  autoload :RGB_COLORS, 'paint/rgb_colors'
+
+  class << self
+    # Takes a string and color options and colorizes the string, fast version without nesting
+    def [](string, *options)
+      return string.to_s if @mode.zero? || options.empty?
+      options = options[0] if options.size == 1 && !options[0].respond_to?(:to_ary)
+      @cache[options] + string.to_s + NOTHING
+    end
+
+    # Takes an array with string and color options and colorizes the string,
+    # extended version with nesting and substitution support
+    def %(paint_arguments, clear_color = NOTHING)
+      string, *options = paint_arguments
+      return string.to_s if options.empty?
+      substitutions = options.pop if options[-1].is_a?(Hash)
+      options = options[0] if options.size == 1 && !options[0].respond_to?(:to_ary)
+      current_color = @cache[options]
+
+      # Substitutions & Nesting
+      if substitutions
+        substitutions.each{ |key, value|
+          string = string.gsub(
+            "%{#{key}}",
+            value.is_a?(Array) ?
+            self.%(value, clear_color + current_color) :
+            value.to_s
+          )
+        }
+      end
+
+      # Wrap string (if Paint.mode > 0)
+      if @mode.zero?
+        string.to_s
+      else
+        current_color + string.to_s + clear_color
+      end
+    end
+
+    # Transforms options into the desired color. Used by @cache
+    def color(*options)
+      return '' if @mode.zero? || options.empty?
+      mix = []
+      color_seen = false
+      colors = ANSI_COLORS_FOREGROUND
+
+      options.each{ |option|
+        case option
+        when Symbol
+          if color = colors[option]
+            mix << color
+            color_seen = :set
+          elsif ANSI_EFFECTS.key?(option)
+            mix << effect(option)
+          else
+            raise ArgumentError, "Unknown color or effect: #{ option }"
+          end
+
+        when Array
+          if option.size == 3 && option.all?{ |n| n.is_a? Numeric }
+            mix << rgb(*[*option, color_seen])
+            color_seen = :set
+          else
+            raise ArgumentError, "Array argument must contain 3 numerals"
+          end
+
+        when ::String
+          if option =~ /\A#?(?<hex_color>[[:xdigit:]]{3}{1,2})\z/ # 3 or 6 hex chars
+            mix << rgb_hex($~[:hex_color], color_seen)
+            color_seen = :set
+          else
+            mix << rgb_name(option, color_seen)
+            color_seen = :set
+          end
+
+        when Numeric
+          integer = option.to_i
+          color_seen = :set if (30..49).include?(integer)
+          mix << integer
+
+        when nil
+          color_seen = :set
+
+        else
+          raise ArgumentError, "Invalid argument: #{ option.inspect }"
+
+        end
+
+        if color_seen == :set
+          colors = ANSI_COLORS_BACKGROUND
+          color_seen = true
+        end
+      }
+
+      wrap(*mix)
+    end
+
+    # This variable influences the color code generation
+    # Currently supported values:
+    # * 0xFFFFFF  - 24-bit (~16 million) colors, aka truecolor
+    # * 256       - 256 colors
+    # * 16        - only ansi colors and bright effect
+    # * 8         - only ansi colors
+    # * 0         - no colorization!
+    attr_reader :mode
+    def mode=(val)
+      @cache.clear
+
+      case val
+      when 0, 8, 16, 256, TRUE_COLOR
+        @mode = val
+      when TrueClass
+        @mode = TRUE_COLOR
+      when nil
+        @mode = 0
+      else
+        raise ArgumentError, "Cannot set paint mode to value <#{val}>, possible values are: 0xFFFFFF (true), 256, 16, 8, 0 (nil)"
+      end
+    end
+
+    # Adds ANSI sequence
+    def wrap(*ansi_codes)
+      "\033[" + ansi_codes*";" + "m"
+    end
+
+    # Creates simple ansi color by looking it up on Paint::ANSI_COLORS
+    def simple(color_name, background = false)
+      (background ? 40 : 30) + ANSI_COLORS[color_name]
+    end
+
+    # If not true_color, creates a 256-compatible color from rgb values,
+    # otherwise, an exact 24-bit color
+    def rgb(red, green, blue, background = false)
+      case @mode
+      when 8
+        "#{background ? 4 : 3}#{rgb_to_ansi(red, green, blue, false)}"
+      when 16
+        "#{background ? 4 : 3}#{rgb_to_ansi(red, green, blue, true)}"
+      when 256
+        "#{background ? 48 : 38}#{rgb_to_256(red, green, blue)}"
+      when TRUE_COLOR
+        "#{background ? 48 : 38}#{rgb_true(red, green, blue)}"
+      end
+    end
+
+    # Creates RGB color from a HTML-like color definition string
+    def rgb_hex(string, background = false)
+      case string.size
+      when 6
+        color_code = string.each_char.each_slice(2).map{ |hex_color| hex_color.join.to_i(16) }
+      when 3
+        color_code = string.each_char.map{ |hex_color_half| (hex_color_half*2).to_i(16) }
+      end
+      rgb(*[*color_code, background])
+    end
+
+    # Creates a RGB from a name found in Paint::RGB_COLORS (based on rgb.txt)
+    def rgb_name(color_name, background = false)
+      if color_code = RGB_COLORS[color_name]
+        rgb(*[*color_code, background])
+      end
+    end
+
+    # Creates the specified effect by looking it up in Paint::ANSI_EFFECTS
+    def effect(effect_name)
+      ANSI_EFFECTS[effect_name]
+    end
+
+    # Determine supported colors
+    # Note: there's no reliable test for 24-bit color support
+    def detect_mode
+      if ENV['NO_COLOR'] # see https://no-color.org/
+        0
+      elsif RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ # windows
+        if ENV['ANSICON']
+          16
+        elsif ENV['ConEmuANSI'] == 'ON'
+          TRUE_COLOR
+        else
+          0
+        end
+      elsif ENV['TERM_PROGRAM'] == 'Apple_Terminal'
+        256
+      else
+        case ENV['TERM']
+        when /^rxvt-(?:.*)-256color$/
+          256
+        when /-color$/, /^rxvt/
+          16
+        else # optimistic default
+          TRUE_COLOR
+        end
+      end
+    end
+
+    private
+
+    # Returns 24-bit color value (see https://gist.github.com/XVilka/8346728)
+    # in ANSI escape sequnce format, without fore-/background information
+    def rgb_true(red, green, blue)
+      ";2;#{red};#{green};#{blue}"
+    end
+
+    # Returns closest supported 256-color an RGB value, without fore-/background information
+    # Inspired by the rainbow gem
+    def rgb_to_256(red, green, blue, approx = true)
+      return ";2;#{red};#{green};#{blue}" unless approx
+
+      gray_possible = true
+      sep = 42.5
+
+      while gray_possible
+        if red < sep || green < sep || blue < sep
+          gray = red < sep && green < sep && blue < sep
+          gray_possible = false
+        end
+        sep += 42.5
+      end
+
+      if gray
+        ";5;#{ 232 + ((red.to_f + green.to_f + blue.to_f)/33).round }"
+      else # rgb
+        ";5;#{ [16, *[red, green, blue].zip([36, 6, 1]).map{ |color, mod|
+          (6 * (color.to_f / 256)).to_i * mod
+        }].inject(:+) }"
+      end
+    end
+
+    # Returns best ANSI color matching an RGB value, without fore-/background information
+    # See https://mail.python.org/pipermail/python-list/2008-December/1150496.html
+    def rgb_to_ansi(red, green, blue, use_bright = false)
+      color_pool =  RGB_COLORS_ANSI.values
+      color_pool += RGB_COLORS_ANSI_BRIGHT.values if use_bright
+
+      ansi_color_rgb = color_pool.min_by{ |col| rgb_color_distance([red, green, blue],col) }
+      if ansi_color = RGB_COLORS_ANSI.key(ansi_color_rgb)
+        ANSI_COLORS[ansi_color]
+      else
+        ansi_color = RGB_COLORS_ANSI_BRIGHT.key(ansi_color_rgb)
+        "#{ANSI_COLORS[ansi_color]};1"
+      end
+    end
+
+    def rgb_color_distance(rgb1, rgb2)
+      rgb1.zip(rgb2).inject(0){ |acc, (cur1, cur2)|
+        acc + (cur1 - cur2)**2
+      }
+    end
+  end
+
+  # init instance vars
+  @mode  = detect_mode
+  @cache = Hash.new{ |h, k| h[k] = color(*k) }
+end