irb-autosuggestions 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02ad5c3a9b0166ac04a5ace310b88b4608ada72fa88d3d0a4f563817042db007
-  data.tar.gz: b68cd6b388fcdfb423ee895ed1758fdd4f8f878cc8c65faf4e45bfc8ffb7ccab
+  metadata.gz: 48eb1b9edb63b8d65e26cb9917c5631ec58ccac72e05ab0c47efa7c2521e84c0
+  data.tar.gz: 7369bbf6293a3ff1c99f733b5026d3d0d6a68305af4330af8ebe5feff8944041
 SHA512:
-  metadata.gz: a16cf68316c28e28aa74993736e78eca09ad0f96fda3e0afb5acfc7c9d1a77ab7804abcc820e7e83055982677f3f2631a276ca3f1a536522b25db912a43a7b55
-  data.tar.gz: bbbc34eaf686fa8c425f83da67c337c06cae44584e2675419b2d8faee4f94859cc8edc3c4ca51f6535bc0496a8e353f744c0ef0c469941978072e04046feacd8
+  metadata.gz: d362044adf712df1f2f36a7305554c837263001d557fe6d999614f51cfd43901b336402326c3008d20c2191c89c60fb54618e79dd785626ceb0abd11eb7d43f4
+  data.tar.gz: d7aee55ff2cd6ec1c49c0b4adeeb890010cda94ffe0b354acb7d63c50081bb6c74c79f8553f820564b592c2ca47cdf8239a492ac1f1a97754be60190ab641635

data/.rubocop.yml

@@ -5,7 +5,7 @@ plugins:
 
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 3.0
+  TargetRubyVersion: 2.7
 
 Style/DoubleNegation:
   Enabled: false

data/.ruby-version

@@ -1 +1 @@
-3.0.7
+2.7.8

data/Gemfile

@@ -2,5 +2,6 @@
 
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in irb-autosuggestions.gemspec
 gemspec
+
+gem 'rbs', '~> 3.6.0', require: false if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0')

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    irb-autosuggestions (0.1.1)
+    irb-autosuggestions (0.2.0)
       reline
 
 GEM
@@ -70,9 +70,10 @@ GEM
     unicode-display_width (3.2.0)
       unicode-emoji (~> 4.1)
     unicode-emoji (4.2.0)
-    yard (0.9.43)
+    yard (0.9.44)
 
 PLATFORMS
+  arm64-darwin-24
   arm64-darwin-25
   x86_64-linux
 
@@ -80,7 +81,7 @@ DEPENDENCIES
   docscribe
   irb-autosuggestions!
   rake
-  rbs
+  rbs (~> 3.6.0)
   rspec (~> 3.0)
   rubocop
   rubocop-rake
@@ -89,4 +90,4 @@ DEPENDENCIES
   yard (>= 0.9.38)
 
 BUNDLED WITH
-   2.5.23
+  4.0.12

data/Gemfile_2_7

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in irb-autosuggestions.gemspec
+gemspec

data/Gemfile_2_7.lock

@@ -0,0 +1,88 @@
+PATH
+  remote: .
+  specs:
+    irb-autosuggestions (0.2.0)
+      reline
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.3)
+    diff-lcs (1.6.2)
+    docscribe (1.3.3)
+      parser (>= 3.3)
+      prism (~> 1.8)
+    io-console (0.8.2)
+    json (2.19.5)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    parallel (1.28.0)
+    parser (3.3.11.1)
+      ast (~> 2.4.1)
+      racc
+    prism (1.9.0)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    rake (13.4.2)
+    regexp_parser (2.12.0)
+    reline (0.6.3)
+      io-console (~> 0.5)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.8)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.7)
+    rubocop (1.86.2)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (>= 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.49.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.49.1)
+      parser (>= 3.3.7.2)
+      prism (~> 1.7)
+    rubocop-rake (0.7.1)
+      lint_roller (~> 1.1)
+      rubocop (>= 1.72.1)
+    rubocop-rspec (3.9.0)
+      lint_roller (~> 1.1)
+      rubocop (~> 1.81)
+    rubocop-sorted_methods_by_call (1.2.2)
+      lint_roller
+      rubocop (>= 1.72.0)
+    ruby-progressbar (1.13.0)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.2.0)
+    yard (0.9.44)
+
+PLATFORMS
+  x86_64-linux
+  arm64-darwin-25
+
+DEPENDENCIES
+  docscribe
+  irb-autosuggestions!
+  rake
+  rspec (~> 3.0)
+  rubocop
+  rubocop-rake
+  rubocop-rspec
+  rubocop-sorted_methods_by_call
+  yard (>= 0.9.38)
+
+BUNDLED WITH
+   2.4.22

data/README.md

@@ -1,7 +1,10 @@
 # Irb::Autosuggestions
 
 [![Gem Version](https://badge.fury.io/rb/irb-autosuggestions.svg)](https://rubygems.org/gems/irb-autosuggestions)
+[![RubyGems Downloads](https://img.shields.io/gem/dt/irb-autosuggestions.svg)](https://rubygems.org/gems/irb-autosuggestions)
 [![CI](https://github.com/unurgunite/irb-autosuggestions/actions/workflows/ci.yml/badge.svg)](https://github.com/unurgunite/irb-autosuggestions/actions)
+[![License](https://img.shields.io/github/license/unurgunite/irb-autosuggestions.svg)](https://github.com/unurgunite/irb-autosuggestions/blob/master/LICENSE.txt)
+[![Ruby](https://img.shields.io/badge/ruby-%3E%3D%202.7-blue.svg)](#installation)
 
 ![Irb::Autosuggestions](readme.png)
 
@@ -13,7 +16,9 @@ No need to explain. Fish-like autosuggestions for IRB — ghost text from histor
     * [Contents](#contents)
     * [Installation](#installation)
     * [Usage](#usage)
+        * [Prefix-filtered history navigation](#prefix-filtered-history-navigation)
     * [Configuration](#configuration)
+        * [Colors](#colors)
         * [How it works](#how-it-works)
     * [Development](#development)
     * [License](#license)
@@ -34,7 +39,8 @@ require 'irb-autosuggestions'
 
 ## Usage
 
-Start typing in IRB. Gray ghost text appears after the cursor, showing the most recent matching history entry:
+Start typing in IRB. Ghost text appears after the cursor, showing the most recent matching history entry with syntax
+coloring (or gray if colorization is unavailable or disabled):
 
 ```
 irb(main):001* [1,2,3].map do |el|
@@ -44,6 +50,36 @@ irb(main):003> end            <- "d" in gray
 
 Press **right arrow** (`->`) to accept the full multiline suggestion.
 
+### Prefix-filtered history navigation
+
+**Up/down arrows** navigate history filtered by the typed prefix (like zsh). Start typing and press **up** — only
+entries matching your prefix are shown. The prefix is frozen on the first press; subsequent presses keep searching
+within that prefix:
+
+```
+irb(main):001:0> def          <- type "def", press up
+irb(main):001:0> def foo      <- press up again then older "def*" entry
+```
+
+Press **right arrow** to accept the suggestion and exit prefix mode. Any non-history key (letter, enter, etc.) resets
+the prefix anchor, returning arrows to normal unfiltered browsing.
+
+Consecutive duplicate entries are collapsed during prefix search so each unique line appears once.
+
+Regular unfiltered history browsing (empty buffer + up arrow) is unchanged — all entries are shown including duplicates.
+
+To disable prefix navigation while keeping ghost text:
+
+```ruby
+IRB.conf[:USE_PREFIX_HISTORY_NAVIGATION] = false
+```
+
+Or via environment variable:
+
+```sh
+export IRB_PREFIX_HISTORY_NAVIGATION=0
+```
+
 ## Configuration
 
 Autosuggestions are enabled by default. To disable:
@@ -60,13 +96,39 @@ Or via environment variable:
 export IRB_AUTOSUGGESTIONS=0
 ```
 
+### Colors
+
+Syntax-colored ghost text is **enabled by default** when `IRB::Color` is available and `IRB.conf[:USE_COLORIZE]` is
+true.
+
+To disable colored ghost text (falls back to plain gray):
+
+```ruby
+IRB.conf[:USE_COLORIZE] = false
+```
+
+Or from command line:
+
+```sh
+irb --nocolorize
+```
+
+> [!NOTE] Colorized ghost rendering may behave differently across terminal emulators, Ruby versions, and IRB color
+> schemes. If you notice visual artifacts (e.g., wrong colors, underlines, or unusual brightness), try disabling the
+> feature or switch to the gray fallback or create new issue.
+
 ### How it works
 
 - Each keystroke queries `Reline::HISTORY` for the most recent entry whose prefix matches the current buffer.
-- The suggestion is rendered inline as gray (`\e[90m`) text without modifying the buffer.
+- The suggestion is rendered inline as ghost text without modifying the buffer.
+- When available, the ghost uses `IRB::Color.colorize_code` to match IRB's syntax colors, dimmed via ANSI escape codes
+  for visual distinction.
 - Extra ghost lines (for multiline history entries) are drawn below the prompt.
-- `\e[J` clears stale ghost artifacts from the viewport.
+- Ghost artifacts are cleared each frame using cursor save/restore (`\e[s`/`\e[u`) and per-line clearing (`\e[2K`),
+  avoiding `\e[J` which interfered with Reline's cursor tracking.
 - Right arrow triggers `ed_next_char`, which replaces the buffer with the ghost text.
+- Up/down arrows use prefix-filtered navigation when the buffer is non-empty, falling back to unfiltered browsing
+  when nothing was typed.
 
 ## Development
 

data/lib/irb/autosuggestions/line_editor_patch.rb

@@ -3,17 +3,26 @@
 module Irb
   module Autosuggestions
     # Patches Reline::LineEditor to display fish-like autosuggestions from history.
+    # rubocop:disable Metrics/ModuleLength, SortedMethodsByCall/Waterfall
     module LineEditorPatch
       GRAY = "\e[90m"
+      DIM = "\e[2m"
+      RESET_COLOR = "\e[39;49m"
       RESET = "\e[0m"
+      FG_COLORS = ((30..37).to_a + (90..97).to_a + [38, 39]).freeze
       CONFIG_KEY = :USE_AUTOSUGGESTIONS
       ENV_KEY = 'IRB_AUTOSUGGESTIONS'
+      CONFIG_NAV_KEY = :USE_PREFIX_HISTORY_NAVIGATION
+      ENV_NAV_KEY = 'IRB_PREFIX_HISTORY_NAVIGATION'
 
-      # Intercepts key input to accept autosuggestions on right arrow.
+      # Intercepts key input to accept autosuggestions on right arrow
+      # and clears the prefix navigation anchor on non-history keys.
       #
       # @param [Object] key A Reline key event.
-      # @return [Object] Returns +super+ for non-right-arrow keys, +nil+ after accept.
+      # @return [Object]
       def input_key(key)
+        clear_prefix_anchor if navigation_enabled? && !history_navigation_key?(key)
+
         if enabled? && right_arrow?(key)
           buffer = whole_buffer
           suggestion = find_suggestion(buffer)
@@ -30,22 +39,149 @@ module Irb
       private
 
       # Injects ghost text into terminal output after Reline finishes rendering.
+      # Clears any previous ghost text (inline and multi-line) first,
+      # then renders the new ghost suggestion.
       #
       # @private
       # @return [Object] The result of +super+.
       def render(...)
         result = super
-        Reline.core.instance_variable_get(:@output).write("\e[J")
-        return result unless enabled?
+        if enabled?
+          clear_previous_ghost
+          render_ghost_suggestion
+        end
+        result
+      end
 
-        buffer = whole_buffer
-        return result if buffer.empty?
+      # Prefix-filtered up-arrow history navigation.
+      #
+      # @private
+      # @param [Object] key
+      # @param [Integer] arg Repeat count.
+      # @return [Object]
+      def ed_prev_history(key, arg: 1)
+        if navigation_enabled? && (@line_index.zero? || @history_pointer)
+          buffer = prefix_buffer_for_nav
+          if buffer && !buffer.empty?
+            walk_history_back(buffer, arg)
+            return
+          end
+        end
+        clear_prefix_anchor
+        super
+      end
 
-        ghost = ghost_for(buffer)
-        return result unless ghost
+      # Prefix-filtered down-arrow history navigation.
+      #
+      # @private
+      # @param [Object] key
+      # @param [Integer] arg Repeat count.
+      # @return [Object]
+      def ed_next_history(key, arg: 1)
+        if navigation_enabled? && @history_pointer && @prefix_buffer
+          walk_history_forward(arg)
+          return
+        end
+        clear_prefix_anchor
+        super
+      end
 
-        render_ghost(ghost)
-        result
+      # Returns the anchor buffer for prefix navigation: the frozen prefix
+      # during an ongoing session, +whole_buffer+ on the first press from
+      # base buffer, or +nil+ when nothing was typed.
+      #
+      # @private
+      # @return [String, nil]
+      def prefix_buffer_for_nav
+        return @prefix_buffer if @prefix_buffer
+
+        whole_buffer unless @history_pointer
+      end
+
+      # Checks if a key event triggers history navigation (up/down arrow).
+      #
+      # @private
+      # @param [Object] key A Reline key event.
+      # @return [Boolean]
+      def history_navigation_key?(key)
+        key.respond_to?(:method_symbol) &&
+          %i[ed_prev_history ed_next_history].include?(key.method_symbol)
+      end
+
+      # Clears ghost from the previous frame: inline text from buffer end
+      # to end of line, and each extra line below. Uses cursor save/restore
+      # so it does not interfere with Reline's cursor tracking.
+      #
+      # @private
+      # @return [void]
+      def clear_previous_ghost
+        clear_inline_ghost
+        return unless @ghost_line_count&.positive?
+
+        output = Reline.core.instance_variable_get(:@output)
+        output.write("\e[s")
+        @ghost_line_count.times { output.write("\e[1B\e[2K") }
+        output.write("\e[u")
+      end
+
+      # Clears inline ghost text from the buffer end to end of line.
+      #
+      # @private
+      # @return [void]
+      def clear_inline_ghost
+        return unless @has_inline_ghost
+
+        output = Reline.core.instance_variable_get(:@output)
+        prompt_width = @prompt ? Reline::Unicode.calculate_width(@prompt) : 0
+        current_line = @buffer_of_lines[@line_index] || ''
+        buf_end = prompt_width + Reline::Unicode.calculate_width(current_line)
+        output.write("\e[s")
+        output.write("\e[0G\e[#{buf_end}C\e[K")
+        output.write("\e[u")
+        @has_inline_ghost = false
+      end
+
+      # Walks backward through history, loading each matching entry.
+      #
+      # @private
+      # @param [String] buffer The prefix anchor.
+      # @param [Integer] arg Repeat count.
+      # @return [Object]
+      def walk_history_back(buffer, arg)
+        arg.times do
+          pointer = find_prev_match(buffer, @history_pointer)
+          break unless pointer
+
+          move_history(pointer, line: :end, cursor: :end)
+          @prefix_buffer = buffer
+        end
+      end
+
+      # Walks forward through history. Returns to base when exhausted.
+      #
+      # @private
+      # @param [Integer] arg Repeat count.
+      # @return [Object]
+      def walk_history_forward(arg)
+        arg.times do
+          pointer = find_next_match(@prefix_buffer, @history_pointer)
+          if pointer
+            move_history(pointer, line: :start, cursor: :end)
+          else
+            move_history(Reline::HISTORY.size, line: :start, cursor: :end)
+            break
+          end
+        end
+      end
+
+      # Removes the prefix anchor so the next up/down starts fresh.
+      #
+      # @private
+      # @return [void]
+      def clear_prefix_anchor
+        return unless instance_variable_defined?(:@prefix_buffer)
+
+        remove_instance_variable(:@prefix_buffer)
       end
 
       # Checks whether autosuggestions are enabled via IRB.conf or env var.
@@ -56,7 +192,24 @@ module Irb
         case ENV.fetch(ENV_KEY, nil)
         when '0' then false
         when '1' then true
-        else IRB.conf.fetch(CONFIG_KEY, true)
+        else
+          val = IRB.conf[CONFIG_KEY]
+          val.nil? || val
+        end
+      end
+
+      # Whether prefix-filtered history navigation is enabled.
+      # Falls back to the value of +enabled?+ when not explicitly set.
+      #
+      # @private
+      # @return [Boolean]
+      def navigation_enabled?
+        case ENV.fetch(ENV_NAV_KEY, nil)
+        when '0' then false
+        when '1' then true
+        else
+          val = IRB.conf[CONFIG_NAV_KEY]
+          val.nil? ? enabled? : val
         end
       end
 
@@ -70,41 +223,225 @@ module Irb
           key.method_symbol == :ed_next_char
       end
 
-      # Computes the ghost text for a given buffer by finding the matching history entry.
+      # Finds the index of the previous (older) history entry starting with +buffer+.
       #
       # @private
-      # @param [String] buffer The current whole buffer.
-      # @return [String, nil] The remaining text of the suggestion, or nil.
-      def ghost_for(buffer)
+      # @param [String] buffer Search prefix.
+      # @param [Integer, nil] from_pointer Current history pointer (nil = base buffer).
+      # @return [Integer, nil]
+      def find_prev_match(buffer, from_pointer)
+        start_idx = (from_pointer || Reline::HISTORY.size) - 1
+        return nil if start_idx.negative?
+
+        start_idx.downto(0) do |i|
+          entry = Reline::HISTORY[i]
+          next if entry.nil? || (dedup?(buffer) && duplicate_of_newer?(i, entry))
+
+          return i if entry.start_with?(buffer)
+        end
+        nil
+      end
+
+      # Finds the index of the next (newer) history entry starting with +buffer+.
+      #
+      # @private
+      # @param [String] buffer Search prefix.
+      # @param [Integer, nil] from_pointer Current history pointer.
+      # @return [Integer, nil]
+      def find_next_match(buffer, from_pointer) # rubocop:disable Metrics/CyclomaticComplexity
+        return nil unless from_pointer
+
+        start_idx = from_pointer + 1
+        return nil if start_idx > Reline::HISTORY.size - 1
+
+        (start_idx...Reline::HISTORY.size).each do |i|
+          entry = Reline::HISTORY[i]
+          next if entry.nil? || (dedup?(buffer) && duplicate_of_newer?(i, entry))
+
+          return i if entry.start_with?(buffer)
+        end
+        nil
+      end
+
+      # Whether duplicate collapsing is active (only for prefix search).
+      #
+      # @private
+      # @param [String] buffer Search prefix.
+      # @return [Boolean]
+      def dedup?(buffer)
+        !buffer.empty?
+      end
+
+      # Whether +entry+ at index +idx+ is a consecutive duplicate of the next entry.
+      #
+      # @private
+      # @param [Integer] idx
+      # @param [String] entry
+      # @return [Boolean]
+      def duplicate_of_newer?(idx, entry)
+        idx < Reline::HISTORY.size - 1 && entry == Reline::HISTORY[idx + 1]
+      end
+
+      # Renders ghost text for the current buffer, if a suggestion exists.
+      #
+      # @private
+      # @return [void]
+      def render_ghost_suggestion
+        buffer = whole_buffer
+        @ghost_line_count = 0
+        return if buffer.empty?
+
         suggestion = find_suggestion(buffer)
         return unless suggestion
 
         ghost = suggestion[buffer.size..]
         return if ghost.nil? || ghost.empty?
 
-        ghost
+        render_ghost(ghost, suggestion)
+      end
+
+      # Finds the most recent history entry that starts with the given buffer.
+      #
+      # @private
+      # @param [String] buffer The current whole buffer.
+      # @return [String, nil] The matching history entry, or nil.
+      def find_suggestion(buffer)
+        Reline::HISTORY.reverse.find do |h|
+          h != buffer && h.start_with?(buffer)
+        end
+      end
+
+      # Replaces the entire buffer with the accepted suggestion and triggers a rerender.
+      #
+      # @private
+      # @param [String] suggestion The full multiline suggestion to accept.
+      # @return [void]
+      def accept_suggestion(suggestion)
+        sug_lines = suggestion.split("\n")
+        @buffer_of_lines = sug_lines
+        @line_index = sug_lines.size - 1
+        @byte_pointer = sug_lines.last.bytesize
+        rerender
       end
 
       # Writes the ghost text (inline + extra lines) to terminal output.
       #
+      # If +suggestion+ is provided and colorization is enabled, the ghost
+      # is rendered with syntax highlighting via IRB::Color.
+      #
       # @private
-      # @param [String] ghost The full ghost text (may contain newlines).
+      # @param [String] ghost The ghost text (suffix of the suggestion).
+      # @param [String, nil] suggestion The full matching history entry.
       # @return [void]
-      def render_ghost(ghost)
-        lines = ghost.split("\n")
+      def render_ghost(ghost, suggestion = nil)
+        output = Reline.core.instance_variable_get(:@output)
+        display_lines = ghost_display_lines(ghost, suggestion)
+        @ghost_line_count = display_lines.size - 1
+        @has_inline_ghost = true
+
+        first_line = display_lines.first
+        output.write(first_line) if first_line && !first_line.empty?
+        write_extra_ghost_lines(display_lines.drop(1))
+        restore_cursor_after(display_lines)
+        output.flush
+      end
+
+      # Returns ghost lines ready for terminal output (with ANSI codes).
+      #
+      # When colorization is enabled, the full suggestion is colorized via
+      # IRB::Color and the ghost portion is extracted from the colored output.
+      # Otherwise, each line is wrapped in GRAY/RESET.
+      #
+      # @private
+      # @param [String] ghost The ghost text (suffix of the suggestion).
+      # @param [String, nil] suggestion The full matching history entry.
+      # @raise [StandardError]
+      # @return [Array<String>]
+      def ghost_display_lines(ghost, suggestion)
+        if suggestion && use_colorize?
+          colorize_ghost_lines(ghost, suggestion)
+        else
+          ghost.split("\n").map { |line| "#{GRAY}#{line}#{RESET}" }
+        end
+      rescue StandardError
+        ghost.split("\n").map { |line| "#{GRAY}#{line}#{RESET}" }
+      end
 
-        Reline.core.instance_variable_get(:@output).write("#{GRAY}#{lines.first}#{RESET}") unless lines.first.empty?
+      # Checks whether syntax coloring is available and enabled.
+      #
+      # @private
+      # @return [Boolean]
+      def use_colorize?
+        defined?(IRB::Color) &&
+          IRB::Color.colorable? &&
+          IRB.conf.fetch(:USE_COLORIZE, true)
+      end
+
+      # Colorizes the full suggestion and extracts the ghost portion.
+      #
+      # @private
+      # @param [String] ghost The ghost text (suffix of the suggestion).
+      # @param [String] suggestion The full matching history entry.
+      # @return [Array<String>] Colorized ghost lines with ANSI codes.
+      def colorize_ghost_lines(ghost, suggestion)
+        colored = IRB::Color.colorize_code(suggestion)
+        ghost_byte_start = suggestion.bytesize - ghost.bytesize
+        colored_ghost = extract_ansi_colored_suffix(colored, ghost_byte_start)
+        colored_ghost.split("\n").map { |line| dim_line(line) }
+      end
+
+      # Prepends each ANSI foreground color code with +2;+ (dim)
+      # and strips non-color attributes (bold, underline, reverse…).
+      # Inner full resets are replaced with +RESET_COLOR+ so dim
+      # stays active across token boundaries.
+      #
+      # @private
+      # @param [String] line ANSI-colored line.
+      # @return [String] Dimmed ANSI-colored line.
+      def dim_line(line)
+        inner = line.gsub(/\e\[(\d+(?:;\d+)*)m/) do
+          params = Regexp.last_match(1)
+          next RESET_COLOR if params == '0'
 
-        write_extra_ghost_lines(lines.drop(1))
-        restore_cursor_after(lines)
+          color = params.split(';').map(&:to_i).select { |p| FG_COLORS.include?(p) }
+          color.empty? ? '' : "\e[2;#{color.join(';')}m"
+        end
+        "#{DIM}#{inner}#{RESET}"
+      end
+
+      # Extracts the suffix of an ANSI-colored string starting at a given
+      # visible byte offset, preserving all ANSI codes.
+      #
+      # @private
+      # @param [String] colored_text Text with embedded ANSI escape sequences.
+      # @param [Integer] visible_byte_offset Offset in visible (non-ANSI) bytes.
+      # @return [String]
+      def extract_ansi_colored_suffix(colored_text, visible_byte_offset) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
+        pos = 0
+        visible = 0
+        pending_code = nil
+
+        while visible < visible_byte_offset && pos < colored_text.length
+          if colored_text[pos] == "\e"
+            code_start = pos
+            pos = colored_text.index('m', pos)&.succ || colored_text.length
+            code = colored_text[code_start...pos]
 
-        Reline.core.instance_variable_get(:@output).flush
+            pending_code = [RESET, "\e[m"].include?(code) ? nil : code
+          else
+            visible += 1
+            pos += 1
+          end
+        end
+
+        suffix = colored_text[pos..] || String.new
+        pending_code ? "#{pending_code}#{suffix}" : suffix
       end
 
       # Writes extra ghost lines below the current buffer line with prompt-width alignment.
       #
       # @private
-      # @param [Array<String>] lines Extra ghost lines (excluding the first inline line).
+      # @param [Array<String>] lines Extra lines with ANSI codes (excluding first inline line).
       # @return [void]
       def write_extra_ghost_lines(lines)
         return if lines.empty?
@@ -115,7 +452,7 @@ module Irb
         lines.each do |line|
           output.write("\n\e[K")
           output.write("\e[#{prompt_width}C") if prompt_width.positive?
-          output.write("#{GRAY}#{line}#{RESET}")
+          output.write(line)
         end
       end
 
@@ -134,30 +471,7 @@ module Irb
         output.write("\e[0G")
         output.write("\e[#{pos}C")
       end
-
-      # Finds the most recent history entry that starts with the given buffer.
-      #
-      # @private
-      # @param [String] buffer The current whole buffer.
-      # @return [String, nil] The matching history entry, or nil.
-      def find_suggestion(buffer)
-        Reline::HISTORY.reverse.find do |h|
-          h != buffer && h.start_with?(buffer)
-        end
-      end
-
-      # Replaces the entire buffer with the accepted suggestion and triggers a rerender.
-      #
-      # @private
-      # @param [String] suggestion The full multiline suggestion to accept.
-      # @return [void]
-      def accept_suggestion(suggestion)
-        sug_lines = suggestion.split("\n")
-        @buffer_of_lines = sug_lines
-        @line_index = sug_lines.size - 1
-        @byte_pointer = sug_lines.last.bytesize
-        rerender
-      end
     end
   end
 end
+# rubocop:enable Metrics/ModuleLength, SortedMethodsByCall/Waterfall

data/lib/irb/autosuggestions/version.rb

@@ -2,6 +2,6 @@
 
 module Irb
   module Autosuggestions
-    VERSION = '0.1.1'
+    VERSION = '0.2.0'
   end
 end

data/rbs_collection.lock.yaml

@@ -93,10 +93,6 @@ gems:
   version: 4.0.2
   source:
     type: rubygems
-- name: rdoc
-  version: '0'
-  source:
-    type: stdlib
 - name: regexp_parser
   version: '2.8'
   source:

data/sig/lib/irb/autosuggestions/line_editor_patch.rbs

@@ -1,10 +1,15 @@
 module Irb
   module Autosuggestions
     module LineEditorPatch
+      CONFIG_NAV_KEY: Symbol
+      DIM: String
+      ENV_NAV_KEY: String
+      FG_COLORS: Array[Integer]
       GRAY: String
       RESET: String
       CONFIG_KEY: Symbol
       ENV_KEY: String
+      RESET_COLOR: String
 
       @buffer_of_lines: Array[String]
       @byte_pointer: Integer
@@ -13,9 +18,12 @@ module Irb
       def input_key: (untyped key) -> untyped
       def render: (*untyped) -> untyped
       def enabled?: () -> bool
+      def use_colorize?: () -> bool
       def right_arrow?: (untyped key) -> bool
-      def ghost_for: (String buffer) -> (String | nil)
-      def render_ghost: (String ghost) -> void
+      def render_ghost: (String ghost, ?String suggestion) -> void
+      def ghost_display_lines: (String ghost, ?String suggestion) -> Array[String]
+      def colorize_ghost_lines: (String ghost, String suggestion) -> Array[String]
+      def extract_ansi_colored_suffix: (String colored_text, Integer visible_byte_offset) -> String
       def write_extra_ghost_lines: (Array[String] lines) -> void
       def restore_cursor_after: (Array[String] lines) -> void
       def find_suggestion: (String buffer) -> (String | nil)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: irb-autosuggestions
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - unurgunite
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-23 00:00:00.000000000 Z
+date: 2026-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: reline
@@ -52,20 +52,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: rbs
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -162,6 +148,8 @@ files:
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
+- Gemfile_2_7
+- Gemfile_2_7.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -191,14 +179,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.23
+rubygems_version: 3.4.22
 signing_key:
 specification_version: 4
 summary: Fish-like autosuggestions for irb.