raindown 0.6.0 → 0.8.0

data/lib/raindown/tui/feelings/feelings_log.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'csv'
+require 'fileutils'
+require 'open3'
+require 'time'
+
+module Raindown
+  module TUI
+    # How a method felt: one of Severance's four tempers, woe, frolic, dread or malice, or numb, with an optional note.
+    Feeling = Data.define(:method, :temper, :note) do
+      # What Claude Code is asked, to fix the method.
+      def prompt
+        "Refactor #{method.label} in #{method.path}:#{method.line}. #{felt} " \
+          "Keep its behaviour, follow the project's CLAUDE.md if it has one, and run the specs."
+      end
+
+      def felt
+        return 'It needs a second look.' unless temper
+
+        "It felt like #{temper}#{": #{note}" if note}."
+      end
+    end
+
+    # The feelings everyone's sorted about the code as it is now, kept in .raindown/feelings.csv with the commit they were
+    # felt at, which a node can count, like the README's code debt. A feeling about code that's since changed, or gone, moves to
+    # .raindown/memories.csv, so the feelings stay few, and the history's kept.
+    class FeelingsLog
+      TEMPERS = %w[frolic numb woe dread malice].freeze
+      HEADER = %i[timestamp commit checksum location method temper note].freeze
+      def initialize(root:)
+        @root = root
+        @csv = File.join(root, '.raindown', 'feelings.csv')
+        @memories = File.join(root, '.raindown', 'memories.csv')
+      end
+
+      # Adds the feeling, as the newest, in place of one about the method before, which moves to the memories if it was
+      # about the method's code before it changed.
+      def add(feeling)
+        method = feeling.method
+        row = {
+          timestamp: Time.now.utc.iso8601,
+          commit:,
+          checksum: method.checksum,
+          location: location(method),
+          method: method.label,
+          temper: feeling.temper,
+          note: feeling.note
+        }
+        changed, others = rows.reject { felt_row?(it, method) }.partition { about?(it, method) }
+        append_memories(changed)
+        write_rows(others + [row])
+      end
+
+      # Moves the feelings about methods that have changed, or gone, since they were felt, from the methods there are
+      # now, to the memories.
+      def move_stale_to_memories(methods)
+        now = methods.to_set { method_key(it) }
+        stale, current = rows.partition { !now.include?(key(it)) }
+        return if stale.empty?
+
+        append_memories(stale)
+        write_rows(current)
+      end
+
+      # Read once, and again after a feeling's added.
+      def rows
+        return [] unless File.exist?(@csv)
+
+        @rows ||= CSV.read(@csv, headers: true, header_converters: :symbol).map(&:to_h)
+      end
+
+      # Whether the method's been felt, by its file, name and code's checksum, wherever its line is now. The answer's kept
+      # until a feeling's added.
+      def felt?(method)
+        @felt ||= rows.to_set { key(it) }
+        @felt_methods ||= {}
+        @felt_methods.fetch(method) { @felt_methods[method] = @felt.include?(method_key(method)) }
+      end
+
+      # How the method last felt, while its code's the same as when it was felt, or nil.
+      def temper(method) = rows.reverse.find { felt_row?(it, method) }&.fetch(:temper)
+
+      # How many feelings there are of each temper, in the bins' order.
+      def counts
+        tally = rows.map { it[:temper] }.tally
+        TEMPERS.to_h { [it, tally.fetch(it, 0)] }
+      end
+
+      private
+
+      def felt_row?(row, method) = key(row) == method_key(method)
+
+      def about?(row, method) = path(row) == relative(method.path) && row[:method] == method.label
+
+      # The row's file, without the line the method was on.
+      def path(row) = row[:location].sub(/:\d+\z/, '')
+
+      # The row's file, method and checksum, to match a method's.
+      def key(row) = [path(row), row[:method], row[:checksum]]
+      def method_key(method) = [relative(method.path), method.label, method.checksum]
+
+      # Adds the rows to the memories, of feelings about code that's since changed or gone.
+      def append_memories(rows)
+        return if rows.empty?
+
+        header = !File.exist?(@memories)
+        CSV.open(@memories, 'a') do |csv|
+          csv << HEADER if header
+          rows.each { csv << it.values_at(*HEADER) }
+        end
+      end
+
+      def write_rows(rows)
+        FileUtils.mkdir_p(File.dirname(@csv))
+        CSV.open(@csv, 'w') do |csv|
+          csv << HEADER
+          rows.each { csv << it.values_at(*HEADER) }
+        end
+        @rows = @felt = @felt_methods = nil
+      end
+
+      # The method's file and line.
+      def location(method) = "#{relative(method.path)}:#{method.line}"
+
+      def relative(path) = path.delete_prefix(File.join(@root, ''))
+
+      def commit
+        sha, status = Open3.capture2('git', '-C', @root, 'rev-parse', '--short', 'HEAD', err: File::NULL)
+        sha.strip if status.success?
+      rescue SystemCallError
+        nil
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/feelings_renderer.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+require_relative '../renderers/renderer'
+require_relative 'bins'
+require_relative 'feelings_code_box'
+require_relative 'magnifier'
+require_relative 'motion'
+require_relative 'celebration/scene'
+require_relative 'waffle/waffle'
+
+module Raindown
+  module TUI
+    # Code feelings, right of the files: the methods as clusters of digits in a grid, with the selected one highlighted
+    # and its code below, then why it felt that way while that's typed, then the five bins and how many each holds.
+    # When the batch is refined, it rains over them, then there's a waffle:
+    #     0  0  2  2  2  5  5  9  9  9  9  1
+    #     1  3  3  7  7  7  6  4  4  0  8  8
+    #    ╭─ lib/text.rb:62 · Text#segments_between ──────────── changed 6× ─╮
+    #    │ def segments_between(line, from, to)                              │
+    #    ╰───────────────────────────────────────────────────────────────────╯
+    #    ╭─ 01 ────╮ ╭─ 02 ────╮ ╭─ 03 ────╮ ╭─ 04 ────╮ ╭─ 05 ────╮
+    #    │ FROLIC  │ │ NUMB    │ │ WOE     │ │ DREAD   │ │ MALICE  │
+    #    │ ███░  9 │ │ ████ 41 │ │ ██░░  6 │ │ █░░░  3 │ │ █░░░  2 │
+    #    ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯
+    class FeelingsRenderer < Renderer
+      include Bins
+      include FeelingsCodeBox
+      include Magnifier
+      include Motion
+      include Waffle
+
+      # The columns a cell takes, on a line of its own, its digit small in the middle, which is magnified in a stat's block
+      # digits across the cell and over the cells above and below it when the mouse is over its method.
+      CELL = 3
+      # The drift from which a method's cells are restless, and flicker now and then.
+      RESTLESS = 7
+      # How far a cell's digit is from its method's drift, by its roll out of NOISE_ROLL, so about four in ten are off.
+      NOISE = { 0 => -1, 1 => 1, 2 => -1, 3 => 1, 4 => -2, 5 => 2, 6 => -3, 7 => 3 }.freeze
+      NOISE_ROLL = 20
+      # The smallest grid that's worth refining, below which the pane's red, saying the screen's too small, under a
+      # window with arrows out from its corners, when there's room for it.
+      MIN_COLUMNS = 15
+      MIN_ROWS = 5
+      TOO_SMALL = 'Screen too small.'
+      TOO_SMALL_ART = ['↖       ↗', '  ┌───┐  ', '  └───┘  ', '↙       ↘', ''].freeze
+      TITLE = 'Weekly Batch'
+      BUTTONS = [['Tab', 'Pane', :tab], ['1-5', 'Feel', nil], ['e', 'Edit', :edit], ['x', 'Fix', :execute],
+                 ['/', 'Search', :search], ['q', 'Quit', :quit]].freeze
+
+      def buttons = BUTTONS
+      def page = 'Code feelings'
+
+      # The pane's title, in the middle of the line above the panes, with the border either side, in its colour.
+      def spacer
+        title = " #{TITLE} "
+        title_width = display_width(title)
+        left = [(width - title_width) / 2, 0].max
+        padded([segment('', :blank, width: left), segment(title, :divider, width: title_width),
+                segment('', :blank, width: [width - left - title_width, 0].max)])
+      end
+
+      # The cells come first, as the first draw picks the batch to fill them, unless the screen's too small for a grid.
+      def lines
+        return too_small if too_small?
+
+        cells = view.cells(columns, filled_rows)
+        return instead if view.code_methods.empty? || view.celebration
+
+        below = [*code_box, *bins]
+        (grid(cells, below.length) + below).first(height)
+      end
+
+      private
+
+      def view = navigator.view
+
+      # Instead of the grid, that there's nothing to feel, or the celebration.
+      def instead
+        return blank(" No functions or methods in #{File.basename(navigator.root)} to feel") if view.code_methods.empty?
+
+        celebration(view.celebration)
+      end
+
+      # Rain and fireworks over the pane when the batch is refined, then a waffle popping out, among confetti, balloons and
+      # sparkles.
+      def celebration(celebration)
+        return Scene.new(width:, height:).lines(celebration.frame) if celebration.raining?
+
+        waffle(Scene.new(width:, height:, animations: [Confetti, Balloons, Sparkles]).lines(celebration.popping), celebration.popping)
+      end
+
+      # The rows of the grid around the selected method's, between blank lines that leave the first and last rows room to
+      # be magnified, above the lines below it, and blank lines for any left over.
+      def grid(cells, below)
+        @cells = cells
+        lines = [height - below, 0].max
+        rows = [lines - 2, 0].max
+        first = first_row(cells, columns, rows)
+        grid = magnified([progress_line(cells, first, rows), *grid_rows(cells, first, rows), padded([])], cells, first, rows)
+
+        [*grid, *Array.new([lines - grid.length, 0].max) { padded([]) }].first(lines)
+      end
+
+      # The cells' lines of the rows from the first.
+      def grid_rows(cells, first, rows) = Array.new(rows) { grid_line(cells, (first + it) * columns, columns) }
+
+      def columns = [(width - 1) / CELL, 1].max
+
+      # The grid's rows between its blank lines, above the code box, as tall as it always is until it's expanded, and the
+      # bins, which a batch fills. An expanded box takes rows from the grid, which then scrolls to keep the selected method
+      # in view.
+      def filled_rows = [height - 2 - CODE_LINES - BOX_LINES - BIN_LINES, 1].max
+
+      # The first row that shows, with the selected method's row in the middle where there's room.
+      def first_row(cells, columns, rows)
+        last = [((cells.length - 1) / columns) - rows + 1, 0].max
+        ((cells.index(view.cursor).to_i / columns) - (rows / 2)).clamp(0, last)
+      end
+
+      # The cells' line of the row from the index.
+      def grid_line(cells, from, columns)
+        segments = (from...(from + columns)).filter_map do |index|
+          owner = cells[index]
+          next unless owner
+
+          click = Click.new(pane:, index: owner, action: :focus)
+          segment(cell_text(owner, index), grid_style(owner, index), width: CELL, event: click)
+        end
+        padded([segment('', :blank, width: 1), *segments])
+      end
+
+      # The cell's digit, small, where it moves, or blank once its method's felt, but still there to select, which shows it
+      # again with its code.
+      def cell_text(owner, index)
+        return ' ' * CELL if hidden?(owner)
+
+        column = digit_column(owner, index)
+        "#{' ' * column}#{digit(owner, index)}#{' ' * (CELL - 1 - column)}"
+      end
+
+      # The selected method's cells, across the whole of each, on the selection's blue, so they join into one block, or on
+      # green when it's already been felt, and others as they move.
+      def grid_style(owner, index)
+        return cell_style(index) unless owner == view.cursor
+        return :felt_selected if view.batch.felt?(view.code_methods[owner])
+
+        :feelings_selected
+      end
+
+      # Whether the method's felt, and not selected, so its cells are blank, asked once a frame for each method.
+      def hidden?(owner)
+        @hidden ||= Hash.new { |hidden, felt| hidden[felt] = felt != view.cursor && view.batch.felt?(view.code_methods[felt]) }
+        @hidden[owner]
+      end
+
+      # Near the method's drift, from 0 to 9: a cell's checksum rolls a small chance of it being one to three away, and a
+      # restless one flickers one lower now and then.
+      def digit(owner, index)
+        drift = view.code_methods[owner].drift
+        (drift + NOISE.fetch(Zlib.crc32("#{owner}:#{index}") % NOISE_ROLL, 0)).clamp(0, 9) + flicker(owner, index)
+      end
+
+      def too_small? = columns < MIN_COLUMNS || filled_rows < MIN_ROWS
+
+      # The pane in red, saying the screen's too small, in the middle, with the cells laid out without picking a batch for
+      # so small a grid, so the keys still move between them.
+      def too_small
+        view.cells(columns)
+        shown = [*TOO_SMALL_ART, TOO_SMALL]
+        shown = [TOO_SMALL] if shown.length > height
+        lines = Array.new(height, '')
+        lines[(height - shown.length) / 2, shown.length] = shown
+        lines.map { [segment(it.center(width), :too_small)] }
+      end
+
+      def blank(message)
+        [[segment(message, :feelings)], *Array.new([height - 1, 0].max) { [segment('', :blank)] }].first(height)
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/feelings_view.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative '../code_box'
+require_relative '../events'
+require_relative 'cell_moves'
+require_relative 'celebration/celebration'
+require_relative 'code_methods'
+require_relative 'feelings_log'
+require_relative 'weekly_batch'
+
+module Raindown
+  module TUI
+    # Code feelings, like Severance's macrodata refinement: the project's functions and methods, in any language,
+    # as clusters of digits in a grid, where long methods, and ones whose files keep changing, drift. The cursor moves
+    # between them, the selected one's code shows below the grid, its first lines or with Enter all that fits, and 1 to 5
+    # sort how it feels into a bin: frolic, numb, woe, dread or malice, which notes it down in the FeelingsLog,
+    # staying on it. Woe, dread and malice ask why first, typed until Enter, or Esc to leave it out. E opens the method in the
+    # editor, and X asks Claude Code to fix it, and either way it's read again after, to be felt again.
+    class FeelingsView
+      include CellMoves
+      include ShownCode
+
+      # Best to worst, as CodeHealth scores them, so the keys rate the code.
+      BINS = { bin1: 'frolic', bin2: 'numb', bin3: 'woe', bin4: 'dread', bin5: 'malice' }.freeze
+      # The tempers that ask why.
+      NOTED = %w[woe dread malice].freeze
+      # Its own keys, besides the bins: Enter and Space show all of the selected method's code, or its first lines again.
+      # Ctrl+T celebrates, to try the rain and the waffle, and isn't shown with the buttons.
+      KEYS = %i[up down left right edit execute enter toggle expand celebrate].freeze
+
+      # The temper being noted, and the note typed so far, while it's asking why, whether the selected method's code
+      # shows all that fits, until another's selected, and the rain then the waffle, once the batch is refined.
+      attr_reader :noting, :note, :cursor, :log, :celebration
+
+      def initialize(root:)
+        @root = root
+        @log = FeelingsLog.new(root:)
+        @last_feelings = {}
+        @cursor = 0
+        @week = WeeklyBatch.new(log: @log)
+      end
+
+      def renderer = FeelingsRenderer
+      def target = self
+      # It shows Ruby code, which isn't written back.
+      def path = nil
+      def changed? = false
+      def typing? = !noting.nil?
+
+      # As fast as an animation while it celebrates, through the rain and the waffle, and otherwise reactive, so its digits
+      # tremble at the same pace whether it's used with the keys or the mouse.
+      def pace(_hovered)
+        return :animation if celebration
+
+        :reactive
+      end
+
+      # Opening it says nothing, as its title is above the grid.
+      def status(_navigator) = [:info, '']
+
+      # Reads the code again, keeping the batch, like after a method's edited or fixed, and the selected method, by its
+      # file and name, even when the methods around it change, moving the feelings about code that's changed, or gone, to
+      # the memories.
+      def load
+        was = selected
+        every = CodeMethods.list(@root)
+        @log.move_stale_to_memories(every)
+        @week.read(every)
+        reselect(was)
+      end
+
+      # Selects the method again, by its file and name, wherever it is now, or keeps the cursor where it was.
+      def reselect(was)
+        self.cursor = code_methods.index { [it.path, it.label] == [was&.path, was&.label] } || @cursor
+      end
+
+      # The Batch of files whose methods are in the grid.
+      def batch = @week.batch
+      def code_methods = batch.code_methods
+
+      def selected = code_methods[@cursor]
+
+      def cursor=(index)
+        index = index.clamp(0, [code_methods.length - 1, 0].max)
+        @expanded = false unless index == @cursor
+        @cursor = index
+      end
+
+      # Every key while it's asking why or celebrating, and otherwise its own, but Tab to the files, or left from the
+      # first method.
+      def next_step?(key)
+        return true if typing? || celebration
+
+        (KEYS.include?(key) || BINS.key?(key)) && !(key == :left && @cursor.zero?)
+      end
+
+      def next_step(key)
+        return note_step(key) if typing?
+        return @celebration = nil if celebration&.over?(key)
+        return (@celebration = Celebration.new).then { nil } if key == :celebrate
+        return unless selected
+        return feel(BINS[key]) if BINS.key?(key)
+
+        method_step(key)
+      end
+
+      private
+
+      # Moves between the methods, or acts on the selected one.
+      def method_step(key)
+        case key
+        when :left then move(-1)
+        when :right then move(1)
+        when :up then move_row(-1)
+        when :down then move_row(1)
+        when :edit then Edit.new(path: selected.path, line: selected.line)
+        when :execute then fix
+        when :enter, :toggle, :expand then toggle_expanded
+        end
+      end
+
+      # Asks to fix the method, with how it last felt, by its file and name, which stay the same when its lines change.
+      def fix = Fix.new(feeling: @last_feelings[[selected.path, selected.label]] || Feeling.new(method: selected, temper: nil, note: nil))
+
+      # Frolic and numb are noted down straight away, while the rest ask why first.
+      def feel(temper)
+        return note_down(temper, nil) unless NOTED.include?(temper)
+
+        @noting = temper
+        @note = +''
+        nil
+      end
+
+      def note_step(key)
+        case key
+        when Type then @note << key.text
+        when :backspace then @note.chop!
+        when :enter then return note_down(@noting, (@note unless @note.strip.empty?))
+        when :escape then return note_down(@noting, nil)
+        end
+        nil
+      end
+
+      # Notes the feeling down, staying on the method, so it can be fixed with what was just said about it. It rains
+      # when that refines the batch.
+      def note_down(temper, note)
+        feeling = Feeling.new(method: selected, temper:, note:)
+        @last_feelings[[selected.path, selected.label]] = feeling
+        @noting = nil
+        refined = batch.refined?
+        @log.add(feeling)
+        @celebration = Celebration.new if !refined && batch.refined?
+        Felt.new(feeling:)
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/magnifier.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative '../../stat'
+
+module Raindown
+  module TUI
+    # Code feelings' magnified digits: the method the mouse is over's, in purple and lavender by turns, so the digits
+    # beside and below each other stand apart, each in a stat's block digits across its cell and the cells above and below
+    # it, drawn over the grid.
+    module Magnifier
+      private
+
+      # The lines with the digits of the method the mouse is over magnified, each across its cell and the cells above and
+      # below it.
+      def magnified(lines, cells, first, rows)
+        magnified_cells(cells, first, rows).each do |index|
+          magnify_cell(lines, (index / columns) - first, cells[index], index)
+        end
+        lines
+      end
+
+      # The cell's digit magnified over its row's line, the top one, and the lines above and below it.
+      def magnify_cell(lines, top, owner, index)
+        style = magnified_style(index)
+        Stat::DIGITS[digit(owner, index).to_s].each_with_index do |text, line|
+          magnify(lines, top + line, segment(text, style, width: FeelingsRenderer::CELL), 1 + (index % columns * FeelingsRenderer::CELL))
+        end
+      end
+
+      # Purple and lavender in turn, along the cell's row and down its column, like a chessboard's squares.
+      def magnified_style(index)
+        return :feelings_purple if ((index / columns) + (index % columns)).odd?
+
+        :feelings
+      end
+
+      # How much of the batch is refined, at the right of the line above the grid, or nothing while a magnified digit
+      # reaches it there.
+      def progress_line(cells, first, rows)
+        progress = "#{view.batch.progress} "
+        start = width - display_width(progress)
+        return padded([]) if magnified_from?(cells, first, rows, start)
+
+        padded([segment('', :blank, width: [start, 0].max), segment(progress, :body, width: display_width(progress))])
+      end
+
+      # Whether a magnified digit in the first row reaches the column, or past it.
+      def magnified_from?(cells, first, rows, column)
+        magnified_cells(cells, first, rows).any? { (it / columns) == first && 1 + (((it % columns) + 1) * FeelingsRenderer::CELL) > column }
+      end
+
+      # The cells of the rows from the first that are the method the mouse is over's, unless they're blank or selected,
+      # which keeps its selection's style.
+      def magnified_cells(cells, first, rows)
+        (first * columns...(first + rows) * columns).select do |index|
+          owner = cells[index]
+          owner && owner != view.cursor && navigator.hovered == Click.new(pane:, index: owner, action: :focus) && !hidden?(owner)
+        end
+      end
+
+      # The segment over the line at the column, clicking whatever cell it covers, so the mouse over it is over that cell.
+      def magnify(lines, line, segment, column)
+        covered = segments_between(lines[line], column, column + display_width(segment.text)).first
+        lines[line] = overlay_segments(lines[line], [segment.with(event: covered&.event)], column:)
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/motion.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+module Raindown
+  module TUI
+    # How Code feelings' digits move in their cells: the restless ones, the heaviest, now and then flicker one lower, and
+    # the ones beside the method the mouse is over flee from it, to the far side of their cells, where they tremble often,
+    # as if they're trying to escape, while every cell around it is bold.
+    module Motion
+      # The columns a fleeing digit moves by when it trembles, each for a step of FLEEING_TREMBLE_SECONDS, a little longer
+      # than a frame, so none are missed, once every FLEEING_TREMBLE_EVERY of them, about every 0.7 seconds, each cell at its
+      # own moment.
+      TREMBLE = [1, -1, 1, -1].freeze
+      FLEEING_TREMBLE_SECONDS = 0.09
+      FLEEING_TREMBLE_EVERY = 8
+      # The columns a digit flees by, from the method beside it, from the middle of its cell, where it's still.
+      FLEE = 1
+      MIDDLE = 1
+      # A restless digit flickers one lower for FLICKER_SECONDS, once every FLICKER_EVERY of them, about every 30 seconds.
+      FLICKER_SECONDS = 0.5
+      FLICKER_EVERY = 60
+
+      private
+
+      # The column of the cell's digit in its cell: the middle, or fleeing to its edge, where it trembles often.
+      def digit_column(owner, index)
+        away = flee(index)
+        return MIDDLE if away.zero?
+
+        fleeing_column(owner, index, away)
+      end
+
+      # At the edge of its cell it's fled to, trembling often and quickly, but never out of the cell.
+      def fleeing_column(owner, index, away)
+        (MIDDLE + away + tremble(owner, index)).clamp(0, FeelingsRenderer::CELL - 1)
+      end
+
+      # A column either way, during the cell's moment once every FLEEING_TREMBLE_EVERY steps, or else none.
+      def tremble(owner, index)
+        TREMBLE.fetch(((now / FLEEING_TREMBLE_SECONDS).floor + Zlib.crc32("#{owner}:#{index}")) % FLEEING_TREMBLE_EVERY, 0)
+      end
+
+      # One lower, during the restless cell's moment once every FLICKER_EVERY steps of FLICKER_SECONDS, or else none.
+      def flicker(owner, index)
+        return 0 if view.code_methods[owner].drift < FeelingsRenderer::RESTLESS
+        return 0 unless (((now / FLICKER_SECONDS).floor + Zlib.crc32("#{owner}:#{index}")) % FLICKER_EVERY).zero?
+
+        -1
+      end
+
+      # The time the frame's drawn at, in seconds, the same for all its cells.
+      def now = @now ||= Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      # Away from the method the mouse is over, when it's beside the cell in its row.
+      def flee(index)
+        away = 0
+        away += FLEE if beside_hovered?(index, -1)
+        away -= FLEE if beside_hovered?(index, 1)
+        away
+      end
+
+      # Whether the cell a step along its row, -1 to the left or 1 to the right, is the method the mouse is over's, and
+      # this one isn't.
+      def beside_hovered?(index, step)
+        ((index % columns) + step).between?(0, columns - 1) && hovered.include?(index + step) && !hovered.include?(index)
+      end
+
+      # Bold around the method the mouse is over, beside it, above it, below it, or diagonally.
+      def cell_style(index)
+        @nearby ||= hovered.flat_map { around(it) }.to_set - hovered
+        return :nearby if @nearby.include?(index)
+
+        :feelings
+      end
+
+      # The cells around the cell, in the rows above and below it and beside it in its own.
+      def around(index)
+        column = index % columns
+        [-1, 0, 1].product([-1, 0, 1]).filter_map do |down, across|
+          next if (down.zero? && across.zero?) || !(column + across).between?(0, columns - 1)
+
+          index + (down * columns) + across
+        end
+      end
+
+      # The cells of the method the mouse is over, by their index.
+      def hovered
+        @hovered ||= @cells.each_index.select { navigator.hovered == Click.new(pane:, index: @cells[it], action: :focus) }.to_set
+      end
+    end
+  end
+end