ruby-wordle 0.9.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 911b41c72a106def560cc14de90dce996c354e615054d67ea3d3c150a29dad21
-  data.tar.gz: 80a2fabaa942be49066e69af631ae473b2f5b774439fb2aa626e7e6748f3498f
+  metadata.gz: 51eede7bb7e30665d22be4809b5c09bb3dcfb66e5416c8277bedc9b6bdb1d49a
+  data.tar.gz: f405f666093a941be20589aa4c9088f0e656d4fd7bb8d05d2defe1d66133ce10
 SHA512:
-  metadata.gz: b363d91c62414d150ae0675ea0345253659d20e7f2202c0c2a2fa5ba516125ace8f3a3023c21878dbf29b0c0d8a990c9ed755d4ac4fc0b2ed3ab47a6998660a3
-  data.tar.gz: 77816914e691cae8ee15bd5a11d8ff1e2c06b873d88de5bbb5b7c3e2e9676a8cd87d7674c7cbdb0f996546e82c28baea718b904a70a6b6cfb506e4b1d407480e
+  metadata.gz: 79c4f52565e7ad89f16e4ac16424e118a229c536d2fa9c9da9f1fb8bc0a04bf9ed98a6eacd82593bad6552fd672e1e3c87a5e391ca38f257c2112852e15207ae
+  data.tar.gz: b8942dece7ac63abab3173a7ee381b6b6e0423f5df9c4a90b4a6241e0f1fb33bd42be18d828909437bf1c5fda66d22f43fa003c737b6fe9608adf15eced826f8

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## 1.0.0
+
+- Changed: The solver takes each guess with its colors on one line (`crane xyxxg`) and supports `undo`, `reset` and `all`.
+- Changed: `ruby-wordle solve GUESS:COLORS ...` prints the candidates without prompting.
+- Changed: The solver shows the turns as tiles and groups the candidates into common and other words, updated in place on a terminal.
+- Changed: The solver ends when a guess gets all green and asks whether to solve another.
+- Changed: The solver ranks the next guess by the expected number of words left instead of listing a random sample.
+- Changed: The game shows the board and a keyboard with the colors of every letter tried, updated in place on a terminal.
+- Changed: After a game, `s` copies the result as emoji squares to the clipboard.
+- Changed: In the game, `?` shows only how many words still fit, and `hint letter` reveals one letter; the answer is never shown during the game, and a game with hints is marked `(assisted)`.
+- Changed: Ruby 3.2 or later is required; input uses Reline.
+- Changed: Tiles use fixed colors that look the same in every terminal theme.
+- Changed: Colors are turned off with `--no-color`, a non-empty `NO_COLOR`, or when the output is not a terminal.
+- Changed: The installed gem includes only the 5-letter word lists. Use the repository for the source lists and `rake wordlists`.
+- Fixed: Repeated letters are colored as in Wordle, and the solver handles them exactly.
+- Fixed: The game no longer picks answers that cannot be typed or are not in the word list.
+- Fixed: End of input and Ctrl-C exit cleanly.

data/README.md

@@ -1,6 +1,6 @@
 # Ruby-Wordle
 
-A set of ruby scripts to generate word-lists, solve Wordle, and play Wordle on the command line
+Play Wordle and solve Wordle on the command line
 
 ⬜️⬜️⬜️⬜️⬜️ \
 ⬜️⬜️⬜️🟨🟨 \
@@ -12,81 +12,111 @@ A set of ruby scripts to generate word-lists, solve Wordle, and play Wordle on t
 
 ### Installation
 
+Requires Ruby 3.2 or later.
+
 ```
-> gem install ruby-wordle
+gem install ruby-wordle
 ```
 
 ----
 
 ### Play Wordle
 
-**Usage Example**
-
-```plain-text
-> ruby-worldle play
 ```
+ruby-wordle play
+```
+
+<img src="https://github.com/yohasebe/ruby-wordle/raw/main/img/play.png" width="500" alt="A game solved in four guesses" />
+
+Guess the 5-letter word in 6 tries. After each guess, the board shows each letter on a green tile (right place), a yellow tile (in the word, elsewhere) or a gray tile (not in the word, or already marked as many times as it occurs), and the keyboard below it shows the best color found for every letter so far. On a terminal, the board is updated in place; when the output below it no longer fits on the screen, the window is resized, or the input has non-ASCII characters, a new board is printed below instead.
+
+| Input | Action |
+| --- | --- |
+| a 5-letter word | Make a guess |
+| `?` | Show how many common words still fit your guesses |
+| `hint letter` | Reveal the letter at the first position not yet guessed correctly (once per game, and only while at least two such positions remain) |
+| `q` | Give up and show the answer |
 
-<img src='https://github.com/yohasebe/ruby-wordle/blob/main/img/ruby-wordle-play.png?raw=true' width='500' />
+After a game with at least one guess, type `s` at the `Play again?` prompt to copy the result as emoji squares (🟩🟨⬛) to the clipboard, ready to paste into a post. Hints do not use up a guess, but a game with hints is marked `(assisted)` in the result and the copied text. A letter hint can still be enough to work out the word. Where no clipboard command is available (`pbcopy`, `wl-copy`, `xclip` or `xsel`), the result is printed instead.
 
-You can ask for help by typing "?↵" while playing. In the suggestion list, basic words consisting of 5 different letters are printed in red 🟥 while basic words having the same letters used more than once are printed in blue 🟦
+Answers are picked from a list of about 1,600 common words. Guesses are accepted from a list of about 16,000 words.
 
 ----
 
 ### Wordle Solver
 
-**Usage Example**
-
-```plain-text
-> ruby-worldle solver
+```
+ruby-wordle solve
 ```
 
-<img src='https://github.com/yohasebe/ruby-wordle/blob/main/img/ruby-wordle-solver.png?raw=true' width='500' />
+Enter each guess you made in a Wordle game together with the colors it got, one character per letter: `g` green, `y` yellow, `x` gray (`2`, `1`, `0` also work).
 
-In the result list, basic words consisting of 5 different letters are printed in red 🟥 while basic words having the same letters used more than once are printed in blue 🟦
+```
+1 > crane yxxyg
+2 > niche yxyxg
+```
 
-----
+<img src="https://github.com/yohasebe/ruby-wordle/raw/main/img/solve.png" width="700" alt="The solver after two guesses" />
 
-### Word Lists
+After each line, the solver shows how many words are still possible, the best next guesses, and the possible words, grouped into common words from the basic word list and other words. Every listed word fits the colors. On a terminal, the turns and the possible words are updated in place, as in the game. When a guess gets all green, the solver asks whether to solve another.
 
-#### Word List Generator Script
+The next guesses are ranked by the expected number of common words left after playing them (shown as `~3.8`). Words that can still be the answer are in bold; the others are in gray (marked `(probe)` without colors) and are good for narrowing down the answer but cannot be it.
 
-🟢 `lib/ruby-wordle/script-filter.rb`
+| Input | Action |
+| --- | --- |
+| `GUESS COLORS` | Add a turn, e.g. `crane xyxxg` |
+| `undo` | Remove the last turn |
+| `reset` | Start over |
+| `all` | List every possible word |
+| `q` | Quit |
 
-A ruby script to generate *n*-letter word lists (`word-list.txt` and `word-list-uniq.txt`)
+To get the result without prompts, pass the turns as arguments:
 
-The default *n* value is 5. Change `NUM_LETTERS` if necessary, and run the script as follows. A directory will be created automatically with the title having the number specified in the script (e.g. `word-lists/5-letters`, `word-lists/6-letters`) and resulting word lists will be stored in that directory.
+```
+ruby-wordle solve crane:xxxxx pilot:yygxy
+```
 
 ----
 
-#### Lists of English Words of 5 Letters (useful to solve Wordle)
-
-🟡 `word-lists/5-letters/word-list.txt`
+### Colors
 
-A list of five-letter words, generated from the original word list.
+Colors are off when the output is not a terminal, when `NO_COLOR` is set to a non-empty value, or with `--no-color`. Without colors, `[A]` is green, `(A)` is yellow and a lowercase letter is gray.
 
-🟡 `word-lists/5-letters/word-list-uniq-letters.txt`
+----
 
-A list of five-letter words consisting of five different letters, generated from the original word list.
+### Word Lists
 
-🟡 `word-lists/5-letters/word-list-basic.txt`
+The 5-letter lists used by the game and the solver are in `word-lists/5-letters`:
 
-A list of five-letter words, generated from the basic word list.
+| File | Contents |
+| --- | --- |
+| `word-list.txt` | All 5-letter words (accepted guesses) |
+| `word-list-uniq-letters.txt` | All 5-letter words with five different letters |
+| `word-list-basic.txt` | Common 5-letter words (answers) |
+| `word-list-basic-uniq-letters.txt` | Common 5-letter words with five different letters |
 
-🟡 `word-lists/5-letters/word-list-basic-uniq-letters.txt`
+They are generated from two source lists in the repository:
 
-A list of five-letter words consisting of five different letters, generated from the basic word list.
+- `word-lists/word-list-original.txt`: about 370,000 English words, based on `words_alpha.txt` in [dwyl/english-words](https://github.com/dwyl/english-words)
+- `word-lists/word-list-basic.txt`: about 13,000 basic English words
 
-----
+Only alphabetic words are kept, and capitalized entries in the basic list (proper nouns) are left out of the common words. To generate lists of another length into `word-lists/N-letters`, run in a clone of the repository:
 
-#### Original/Basic Lists of English Words
+```
+bundle install
+bundle exec rake wordlists LENGTH=6
+```
 
-⚪️ `word-lists/word-list-original.txt`
+----
 
-A large word list based on `words_alpha.txt` in [dwyl/english-words](https://github.com/dwyl/english-words), containing more than 370,000 items.
+### Development
 
-⚪️ `word-lists/word-list-basic.txt`
+```
+bundle install
+bundle exec rake test
+```
 
-A smaller word list containing about 13,000 basic English words.
+The screenshots in `img/` are recorded from `img/*.tape` with `bundle exec rake screenshots`, which requires [VHS](https://github.com/charmbracelet/vhs) and ttyd.
 
 ----
 

data/bin/ruby-wordle

@@ -1,24 +1,6 @@
 #!/usr/bin/env ruby
 
-$LOAD_PATH << File.join( File.dirname(__FILE__), '..', 'lib')
-$LOAD_PATH << File.join( File.dirname(__FILE__), '..', 'lib', 'ruby-wordle')
-
-require 'version'
-require 'script-play'
-require 'script-solver'
-
-if ARGV[0] == "-v" || ARGV[0] == "--version"
-  puts "Ruby Wordle #{RubyWordle::VERSION}"
-  exit
-elsif ARGV[0] == "play" || ARGV[0] == "play" || ARGV[0] == "p"
-  RubyWordlePlay::play_wordle
-elsif ARGV[0] == "solver" || ARGV[0] == "solve" || ARGV[0] == "s"
-  RubyWordleSolver::run_interactively
-else
-  puts "Ruby Wordle #{RubyWordle::VERSION}"; puts
-  puts "Usage: ruby-wordle (play|solve)"
-  puts; puts "See https://github.com/yohasebe/ruby-wordle"
-  exit
-end
-
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "ruby-wordle"
 
+exit RubyWordle::CLI.new.run(ARGV)

data/lib/ruby-wordle/cli.rb

@@ -0,0 +1,426 @@
+require "ruby-wordle/version"
+require "ruby-wordle/feedback"
+require "ruby-wordle/dictionary"
+require "ruby-wordle/game"
+require "ruby-wordle/solver"
+require "ruby-wordle/style"
+
+module RubyWordle
+  # Command-line front end for playing and solving.
+  class CLI
+    KEYBOARD = %w[qwertyuiop asdfghjkl zxcvbnm].freeze
+    SUGGESTIONS = 5
+    LISTED = 40
+    COLUMNS = 8
+
+    USAGE = <<~TEXT.freeze
+      Usage: ruby-wordle <command> [options]
+
+      Commands:
+        play                     Play a game against the computer
+        solve                    Find the answer of a game played elsewhere
+        solve GUESS:COLORS ...   Print candidates for the given turns and exit
+
+      COLORS has one character per letter: g = green, y = yellow, x = gray.
+      Example: ruby-wordle solve crane:xyxxg
+
+      Options:
+        --no-color     Disable colors (also when NO_COLOR is not empty)
+        -v, --version  Show the version
+        -h, --help     Show this help
+    TEXT
+
+    CLIPBOARD_COMMANDS = [%w[pbcopy], %w[wl-copy], %w[xclip -selection clipboard], %w[xsel --clipboard --input]].freeze
+
+    # +clipboard+ takes the text to copy and returns whether it was copied.
+    def initialize(input: $stdin, output: $stdout, dictionary: nil, random: Random.new, env: ENV, clipboard: nil)
+      @input = input
+      @output = output
+      @dictionary = dictionary
+      @random = random
+      @clipboard = clipboard || method(:copy_to_system_clipboard)
+      @style = Style.for(output, env)
+    end
+
+    def run(argv)
+      args = argv.dup
+      @style = Style.new(color: false) if args.delete("--no-color")
+      return info("ruby-wordle #{VERSION}") if args.intersect?(%w[-v --version])
+      return info(USAGE) if args.empty? || args.intersect?(%w[-h --help])
+
+      case args.shift
+      when "play", "p" then args.empty? ? (play; 0) : usage_error
+      when "solve", "solver", "s" then args.empty? ? (solve; 0) : solve_once(args)
+      else usage_error
+      end
+    rescue Interrupt
+      say
+      130
+    end
+
+    private
+
+    def dictionary
+      @dictionary ||= Dictionary.default
+    end
+
+    def say(text = "")
+      @output.puts text
+      count_rows(text)
+    end
+
+    def info(text)
+      say text
+      0
+    end
+
+    def usage_error
+      say USAGE
+      1
+    end
+
+    # Reline reads and writes the process's terminal, so it is used only
+    # when the CLI runs on the standard streams of a terminal.
+    def interactive_terminal?
+      @input.equal?($stdin) && @output.equal?($stdout) && @input.tty? && @output.tty?
+    end
+
+    # Returns the stripped line, or nil at end of input.
+    def ask(prompt)
+      line = interactive_terminal? ? read_terminal(prompt) : read_plain(prompt)
+      typed = line&.chomp.to_s
+      # The width of anything but printable ASCII depends on the terminal.
+      @redraw[:reliable] = false if @redraw && !typed.match?(/\A[\x20-\x7e]*\z/)
+      count_rows("#{prompt}#{typed}")
+      line&.strip&.downcase
+    end
+
+    def read_terminal(prompt)
+      require "reline"
+      Reline.readline(prompt, true)
+    end
+
+    def read_plain(prompt)
+      @output.print prompt
+      @input.gets
+    end
+
+    # [height, width] of the terminal, or nil when it is unknown.
+    def terminal_size
+      require "io/console"
+      size = @output.winsize
+      size if size.all?(&:positive?)
+    rescue StandardError
+      nil
+    end
+
+    # --- redraw -------------------------------------------------------------
+    #
+    # On a terminal, the board (in the solver, the turns and the candidates) is
+    # drawn over the previous one together with the prompts, hints and
+    # messages printed below it. The rows printed since the board started are
+    # counted; when the count may be wrong (the window was resized, or input
+    # had characters of unknown width) or the rows no longer fit on the
+    # screen, a new board is printed below instead.
+
+    def start_redraw
+      size = interactive_terminal? && terminal_size
+      @redraw = size ? { rows: 0, size: size, reliable: true } : nil
+    end
+
+    def stop_redraw
+      @redraw = nil
+    end
+
+    def count_rows(text)
+      return unless @redraw
+
+      @redraw[:reliable] = false unless terminal_size == @redraw[:size]
+      width = @redraw[:size].last
+      text.to_s.chomp.split("\n", -1).then { |lines| lines.empty? ? [""] : lines }.each do |line|
+        columns = line.gsub(/\e\[[0-9;]*m/, "").length
+        @redraw[:rows] += [(columns - 1) / width + 1, 1].max
+      end
+    end
+
+    def rewind
+      return unless @redraw
+
+      size = terminal_size
+      rows = @redraw[:rows]
+      if @redraw[:reliable] && size == @redraw[:size] && rows.positive? && rows < size.first
+        @output.print "\e[#{rows}A\r\e[J"
+      end
+      @redraw = size && { rows: 0, size: size, reliable: true }
+    end
+
+    def quit?(line)
+      line.nil? || %w[q quit exit].include?(line)
+    end
+
+    # --- play ---------------------------------------------------------------
+
+    def play
+      loop do
+        game = Game.new(dictionary, random: @random)
+        play_round(game)
+        options = game.history.empty? ? "[y/N]" : "[y/N/s(hare)]"
+        line = ask("Play again? #{options} ")
+        if %w[s share].include?(line) && !game.history.empty?
+          share(game)
+          line = ask("Play again? [y/N] ")
+        end
+        break unless %w[y yes].include?(line)
+      end
+    end
+
+    def play_round(game)
+      say @style.paint("Guess the #{game.length}-letter word in #{game.max_attempts} tries.", :bold, :cyan)
+      say @style.paint("Type ? for a hint, q to give up.", :gray)
+      start_redraw
+      draw(game)
+
+      until game.over?
+        line = ask("#{game.history.size + 1}/#{game.max_attempts} > ")
+        if quit?(line)
+          break
+        elsif ["?", "h", "hint", "help"].include?(line)
+          hint(game)
+        elsif ["hint letter", "letter"].include?(line)
+          hint_letter(game)
+        elsif !line.empty?
+          begin
+            game.guess(line)
+            draw(game)
+          rescue Game::InvalidGuess => e
+            say @style.paint("  Sorry, #{e.message}.", :red)
+          end
+        end
+      end
+
+      stop_redraw
+      finish(game)
+    end
+
+    def draw(game)
+      rewind
+      # Tiles are 3 columns wide with 1-column gaps, so every row has an odd
+      # width and the board and keyboard rows share one center column.
+      width = ->(tiles) { tiles * 4 - 1 }
+      full = width.(KEYBOARD.map(&:size).push(game.length).max)
+      indent = ->(tiles) { "  " + " " * ((full - width.(tiles)) / 2) }
+
+      empty = @style.paint(Array.new(game.length, " · ").join(" "), :dim)
+      board = game.history.map { |word, pattern| @style.row(word, pattern) } + [empty] * game.attempts_left
+      say
+      # A blank line between rows keeps tiles of adjacent rows apart.
+      say board.map { |row| indent.(game.length) + row }.join("\n\n")
+      say
+      states = game.letter_states
+      KEYBOARD.each do |keys|
+        say indent.(keys.size) + keys.chars.map { |c| @style.tile(c, states[c]) }.join(" ")
+      end
+      say
+      return unless game.revealed
+
+      say "  #{letter_clue(game)}"
+      say
+    end
+
+    # Hints never name a word: they count the common words that fit the
+    # guesses so far, or reveal one letter when asked explicitly.
+    def hint(game)
+      solver = Solver.new(dictionary, pool: dictionary.answers)
+      game.history.each { |word, pattern| solver.add(word, pattern) }
+      count = solver.candidates.size
+      return say(@style.paint("  No word in the answer list fits; hints are unavailable.", :red)) if count.zero?
+
+      game.assist!
+      say "  #{count == 1 ? 'One word fits your clues.' : "#{count} words still fit your clues."}"
+      say @style.paint("  For a stronger hint, type: hint letter (reveals one letter, once per game)", :gray) unless game.revealed
+    end
+
+    def hint_letter(game)
+      if game.reveal
+        say "  #{letter_clue(game)}"
+      else
+        say @style.paint("  A letter hint would give away the word.", :red)
+      end
+    end
+
+    def letter_clue(game)
+      position, letter = game.revealed
+      @style.paint("Hint: letter #{position + 1} is #{letter.upcase}", :yellow)
+    end
+
+    def assisted(game)
+      game.assisted? ? " (assisted)" : ""
+    end
+
+    def finish(game)
+      say
+      if game.won?
+        say @style.paint("  Solved in #{game.history.size}/#{game.max_attempts}!#{assisted(game)}", :bold, :green)
+      else
+        say "  The answer was #{@style.paint(game.answer.upcase, :bold)}.#{assisted(game)}"
+      end
+      say
+    end
+
+    # The result as emoji squares, which keep their colors when pasted.
+    def share(game)
+      score = game.won? ? game.history.size : "X"
+      grid = game.history.map { |_, pattern| @style.emoji(pattern, game.length) }
+      text = "ruby-wordle #{score}/#{game.max_attempts}#{assisted(game)}\n\n#{grid.join("\n")}\n"
+      say
+      if @clipboard.call(text)
+        say @style.paint("  Copied the result to the clipboard.", :green)
+      else
+        text.each_line { |line| say "  #{line.chomp}" }
+      end
+      say
+    end
+
+    def copy_to_system_clipboard(text)
+      return false unless interactive_terminal?
+
+      CLIPBOARD_COMMANDS.any? do |command|
+        IO.popen(command, "w", err: File::NULL) { |io| io.write(text) }
+        $?.success?
+      rescue SystemCallError
+        false
+      end
+    end
+
+    # --- solve --------------------------------------------------------------
+
+    def solve
+      solver = Solver.new(dictionary)
+      say @style.paint("Enter each guess and its colors, e.g. crane xyxxg", :bold, :cyan)
+      say @style.paint("g = green, y = yellow, x = gray. Commands: undo, reset, all, q", :gray)
+      start_redraw
+      report(solver)
+
+      loop do
+        line = ask("#{solver.history.size + 1} > ")
+        break if quit?(line)
+
+        case line
+        when "" then next
+        when "undo", "u" then solver.undo
+        when "reset", "r" then solver.reset
+        when "all", "a" then list(solver.candidates, all: true); next
+        else
+          turn = parse_turn(line)
+          next unless turn
+
+          solver.add(*turn)
+        end
+        rewind
+        show_history(solver)
+        report(solver)
+        next unless solved?(solver)
+        break unless %w[y yes].include?(ask("Solve another? [y/N] "))
+
+        solver.reset
+        rewind
+        report(solver)
+      end
+      stop_redraw
+    end
+
+    # The last turn is all green and every turn fits that word. The word need
+    # not be in the word list.
+    def solved?(solver)
+      answer, pattern = solver.history.last
+      return false unless pattern == Feedback.solved(dictionary.length)
+
+      solver.history.all? { |guess, colors| Feedback.score(guess, answer) == colors }
+    end
+
+    def solve_once(args)
+      solver = Solver.new(dictionary)
+      args.each do |arg|
+        turn = parse_turn(arg)
+        return 1 unless turn
+
+        solver.add(*turn)
+      end
+      show_history(solver)
+      report(solver, all: true)
+      solved?(solver) || !solver.candidates.empty? ? 0 : 1
+    end
+
+    # Accepts "crane xyxxg" or "crane:xyxxg".
+    def parse_turn(text)
+      word, colors = text.downcase.split(/[\s:]+/, 2)
+      size = dictionary.length
+      pattern = colors && Feedback.parse(colors, size)
+      if word.to_s.match?(/\A[a-z]{#{size}}\z/) && pattern
+        [word, pattern]
+      else
+        say @style.paint("  Sorry, write a #{size}-letter word and #{size} colors (g, y, x), e.g. crane xyxxg", :red)
+        nil
+      end
+    end
+
+    def show_history(solver)
+      return if solver.history.empty?
+
+      say
+      say solver.history.map { |word, pattern| "  #{@style.row(word, pattern)}" }.join("\n\n")
+    end
+
+    def report(solver, all: false)
+      candidates = solver.candidates
+      say
+      if solved?(solver)
+        say @style.paint("  Solved in #{solver.history.size}!", :bold, :green)
+      else
+        report_candidates(solver, candidates, all)
+      end
+      say
+    end
+
+    def report_candidates(solver, candidates, all)
+      case candidates.size
+      when 0
+        say @style.paint("  No word matches. Check the colors, or type undo.", :red)
+      when 1
+        say "  The answer is #{@style.paint(candidates.first.upcase, :bold, :green)}."
+      else
+        common = candidates.count { |w| dictionary.common?(w) }
+        say "  #{candidates.size} words possible (#{common} common)"
+        tries = solver.suggest(SUGGESTIONS).map do |s|
+          "#{try_word(s)} #{@style.paint(format('~%.1f', s.expected), :dim)}"
+        end
+        say "  Try: #{tries.join('   ')}"
+        list(candidates, all: all)
+      end
+    end
+
+    # A suggestion that cannot be the answer is gray, or marked without colors.
+    def try_word(suggestion)
+      return @style.paint(suggestion.word, :bold) if suggestion.possible
+
+      @style.color? ? @style.paint(suggestion.word, :gray) : "#{suggestion.word} (probe)"
+    end
+
+    # Common words, then the others, at most LISTED in all unless +all+.
+    def list(words, all: false)
+      limit = all ? words.size : LISTED
+      shown = 0
+      common, other = words.partition { |w| dictionary.common?(w) }
+      [["Common words", common], ["Other words", other]].each do |label, group|
+        group = group.first(limit - shown)
+        next if group.empty?
+
+        say
+        say "  #{label}:"
+        group.each_slice(COLUMNS) { |slice| say "  " + slice.join("  ") }
+        shown += group.size
+      end
+      say @style.paint("  ... #{words.size - shown} more (type all)", :gray) if shown < words.size
+    end
+  end
+end