raindown 0.6.0 → 0.8.0

data/lib/raindown/tui/endpoints.rb

@@ -3,7 +3,7 @@
 require_relative 'endpoint'
 require_relative 'views/endpoint_view'
 require_relative 'row'
-require_relative 'workers/worker'
+require_relative '../workers/worker'
 
 module Raindown
   module TUI
@@ -22,7 +22,7 @@ module Raindown
       def load
         @endpoints = @workers.each.flat_map do |worker|
           worker.call(:endpoints)
-        rescue Worker::Error
+        rescue Workers::Worker::Error
           []
         end
       end

data/lib/raindown/tui/events.rb

@@ -7,6 +7,14 @@ module Raindown
     # Keys are their events' names, like :down or :enter.
     Click = Data.define(:pane, :index, :action)
 
+    # The mouse moving over what a click there would send, if anything, to show it, like a method's cells in bold.
+    Hover = Data.define(:target)
+    # The mouse moved with its button held, by columns across and rows down, like to drag a blueprint's canvas.
+    Drag = Data.define(:columns, :rows)
+
+    # A character typed while typing, like in Teleport, which other keys' events would take, like "j" for :down.
+    Type = Data.define(:text)
+
     # What the Screen does after an event, other than drawing again, or stopping for :quit.
     # Leaves the screen for a command, like the editor, then tells the Navigator it ran.
     Run = Data.define(:command)
@@ -15,7 +23,8 @@ module Raindown
     Wait = Data.define(:message, :task)
 
     # Steps a row or a view asks of the Navigator, which each takes on it, returning what the Screen does next: to open
-    # a view right of the files, or a file in the outline at a directive, to edit a file at a line, or to run an endpoint.
+    # a view right of the files, or a file in the outline at a directive, to edit a file at a line, to run an endpoint,
+    # to draw the page a feeling was noted down in, or to ask Claude Code to fix a method.
     OpenView = Data.define(:view) do
       def take(navigator) = navigator.open_view(view)
     end
@@ -31,5 +40,13 @@ module Raindown
     Execute = Data.define(:path, :line, :name) do
       def take(navigator) = navigator.run(path, line, name)
     end
+
+    Felt = Data.define(:feeling) do
+      def take(navigator) = navigator.felt(feeling)
+    end
+
+    Fix = Data.define(:feeling) do
+      def take(navigator) = navigator.fix_with_agent(feeling)
+    end
   end
 end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'zlib'
+
+module Raindown
+  module TUI
+    # Files to feel, like the files Severance's refiners work through: the first in the week's shuffled order, as many as
+    # fill the grid's cells, with their methods shuffled together. The order is random, but the same all week, so the
+    # grid stays put through reloads, edits and restarts, and once it's refined, that's the week's work done.
+    Batch = Data.define(:files, :code_methods, :log, :week) do
+      # Like 2026-W44, from the ISO year and week.
+      def self.this_week(date = Date.today) = "#{date.cwyear}-W#{date.cweek}"
+
+      def self.pick(every, log:, cells:, week: this_week)
+        files = filling(every.group_by(&:path).sort_by { |path, _| Zlib.crc32("#{week}:#{path}") }, cells)
+
+        new(files:, code_methods: [], log:, week:).reading(every)
+      end
+
+      # The files, in order, whose methods' cells fit in the grid's, passing over any too big for what's left, and
+      # at least the first.
+      def self.filling(files, cells)
+        used = 0
+        files.each_with_object([]) do |(path, methods), picked|
+          size = methods.sum(&:size)
+          next unless picked.empty? || used + size <= cells
+
+          picked << path
+          used += size
+        end
+      end
+
+      # The same files, with their methods read again, like after one's edited.
+      def reading(every)
+        with(code_methods: every.select { files.include?(it.path) }.sort_by { Zlib.crc32("#{week}:#{it.path}:#{it.label}") })
+      end
+
+      def felt?(method) = log.felt?(method)
+      def refined? = code_methods.all? { felt?(it) }
+
+      def progress
+        "#{code_methods.count { felt?(it) } * 100 / [code_methods.length, 1].max}% refined"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative 'feelings_log'
+
+module Raindown
+  module TUI
+    # Code feelings' bins below the code box, one for each temper, best to worst, each a box with its key's number, its
+    # temper and a bar of how many feelings it holds, highlighted when it's the chosen temper:
+    #    ╭─ 01 ────╮ ╭─ 02 ────╮ ╭─ 03 ────╮ ╭─ 04 ────╮ ╭─ 05 ────╮
+    #    │ FROLIC  │ │ NUMB    │ │ WOE     │ │ DREAD   │ │ MALICE  │
+    #    │ ███░  9 │ │ ████ 41 │ │ ██░░  6 │ │ █░░░  3 │ │ █░░░  2 │
+    #    ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯ ╰─────────╯
+    module Bins
+      # A bin's lines.
+      BIN_LINES = 4
+
+      private
+
+      # The five bins, each a box with its number, its temper, and a bar of how many feelings it holds.
+      def bins
+        counts = view.log.counts
+        most = [counts.values.max, 1].max
+        chosen = chosen_temper
+        boxes = counts.each_with_index.map { |(temper, count), index| bin(index + 1, temper, count, most, chosen) }
+
+        Array.new(BIN_LINES) do |line|
+          padded([segment('', :blank, width: 1), *boxes.flat_map { [it[line], segment(' ', :blank, width: 1)] }])
+        end
+      end
+
+      # The temper being noted, or else how the selected method felt, if it's been felt.
+      def chosen_temper = view.noting || view.log.temper(view.selected)
+
+      # As wide as they all fit, which cuts their borders short in a pane too narrow for them.
+      def bin_width = [(width - 1 - FeelingsLog::TEMPERS.length) / FeelingsLog::TEMPERS.length, 1].max
+
+      # A space inside a bin's sides, unless the longest temper would only fit without it.
+      def bin_inside
+        return '' if bin_width < FeelingsLog::TEMPERS.map(&:length).max + 4
+
+        ' '
+      end
+
+      # The bin's lines, highlighted when it's the chosen temper: the one being noted, or how the selected method felt.
+      def bin(number, temper, count, most, chosen)
+        style = :feelings
+        style = :selected if temper == chosen
+        bin_lines(number, temper, count, most).map { segment(it, style, width: bin_width) }
+      end
+
+      # Its key's number on its top line, its temper, the bar of its count, and its bottom.
+      def bin_lines(number, temper, count, most)
+        inside = bin_inside
+        name = temper.upcase.ljust(bin_width - 2 - (2 * inside.length))
+        ["╭─ 0#{number} #{'─' * [bin_width - 7, 0].max}╮", "│#{inside}#{name}#{inside}│",
+         "│#{inside}#{bar(count, most)} #{count}#{inside}│", "╰#{'─' * (bin_width - 2)}╯"]
+      end
+
+      # As long as there's room beside the count, and filled as far as its share of the fullest bin's.
+      def bar(count, most)
+        length = bin_width - 3 - (2 * bin_inside.length) - count.to_s.length
+        filled = (length * count / most.to_f).round
+        "#{'█' * filled}#{'░' * (length - filled)}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # When a batch of code feelings is refined, like Severance's waffle party: rain, a frame each tick, for about five
+    # seconds of the Screen's 50 ms frames, then a waffle, until a key's pressed.
+    class Celebration
+      RAIN_FRAMES = 100
+
+      attr_reader :frame
+
+      def initialize
+        @frame = 0
+      end
+
+      def raining? = frame < RAIN_FRAMES
+
+      # The frames since the rain stopped, which pop the waffle.
+      def popping = frame - RAIN_FRAMES
+
+      # Each tick's a frame, and any other key puts the waffle away, which is when it's over.
+      def over?(key)
+        @frame += 1 if key == :tick
+        key != :tick
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/celebration/fireworks.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+require_relative 'rain'
+
+module Raindown
+  module TUI
+    # Fireworks, like over the Rain when a batch of code feelings is refined: rockets rising from the bottom, a row a
+    # tick, that burst in a bright colour into sparks flying out eight ways, which fade, then another rises in their
+    # place. Sparks fly twice as far across as up or down, as the cells are about twice as tall as they're wide:
+    #     ·   ·   ·
+    #      +  +  +
+    #       * * *
+    #   · + * * * + ·
+    #       * * *
+    #      +  +  +
+    #     ·   ·   ·
+    #         ╵
+    #         ·
+    class Fireworks
+      # The columns for each rocket in the air at once.
+      COLUMNS_A_ROCKET = 20
+      # The sparks, a frame each, as they fly out from one in the middle and fade.
+      SPARKS = %w[* * * + + · ·].freeze
+      # The eight ways sparks fly, as columns and rows a frame.
+      WAYS = [[-2, -1], [0, -1], [2, -1], [-2, 0], [2, 0], [-2, 1], [0, 1], [2, 1]].freeze
+      # Where a rocket rises, the row it bursts on, and its colour.
+      Rocket = Data.define(:column, :top, :color)
+
+      attr_reader :width, :height
+
+      def initialize(width:, height:)
+        @width = width
+        @height = height
+      end
+
+      # Draws the rockets and bursts at the tick into a Scene's cells, each rocket a tick apart from the others by a
+      # checksum of it.
+      def draw(cells, tick)
+        [width / COLUMNS_A_ROCKET, 1].max.times do |rocket|
+          launch, frame = (tick + Zlib.crc32("rocket #{rocket}")).divmod(height + SPARKS.length)
+          firework(cells, rocket(Zlib.crc32("rocket #{rocket} #{launch}")), frame)
+        end
+      end
+
+      private
+
+      # A rocket, from the seed, a checksum of it and how many it's launched, bursting in the top half or so.
+      def rocket(seed)
+        Rocket.new(column: seed % width, top: (height / 5) + ((seed >> 8) % [height / 3, 1].max),
+                   color: Rain::COLORS[(seed >> 16) % Rain::COLORS.length])
+      end
+
+      # The rocket rising, with a spark trailing it, or once it's as high as it goes, bursting.
+      def firework(cells, rocket, frame)
+        rising = height - 1 - rocket.top
+        return burst(cells, rocket, frame - rising) if frame >= rising
+
+        put(cells, rocket.column, height - 1 - frame, '╵', rocket.color)
+        put(cells, rocket.column, height - frame, '·', rocket.color)
+      end
+
+      def burst(cells, rocket, frame)
+        return unless (spark = SPARKS[frame])
+
+        WAYS.each { |across, down| put(cells, rocket.column + (across * frame), rocket.top + (down * frame), spark, rocket.color) }
+      end
+
+      def put(cells, column, row, char, color)
+        cells[row][column] = [char, color] if row.between?(0, height - 1) && column.between?(0, width - 1)
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/celebration/rain.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+module Raindown
+  module TUI
+    # Rain, like when a batch of code feelings is refined: drops falling down some of the columns, each at its own speed
+    # and in a bright colour of its own, that splash and spread when they hit the bottom, then fall again from the top
+    # in another colour:
+    #       │          ╎
+    #       ╎    │          │
+    #     │     ╎        │
+    #    · ·   ◦       .   .
+    class Rain
+      # One column in RAINY has a drop.
+      RAINY = 4
+      # The splash, a frame each after a drop hits the bottom, as its distance either side of the drop's column.
+      SPLASH = [[0, '◦'], [1, '·'], [2, '.']].freeze
+      COLORS = %i[bright_red bright_orange bright_yellow bright_green bright_cyan bright_blue bright_purple bright_pink].freeze
+
+      attr_reader :width, :height
+
+      def initialize(width:, height:)
+        @width = width
+        @height = height
+      end
+
+      # Draws the drops at the tick into a Scene's cells.
+      def draw(cells, tick)
+        width.times { drop(cells, it, Zlib.crc32("rain #{it}"), tick) }
+      end
+
+      private
+
+      # The column's drop, if it has one, from the seed, a checksum of the column, like how fast it falls and when it
+      # starts.
+      def drop(cells, column, seed, tick)
+        return unless (seed % RAINY).zero?
+
+        falling = (height + speed(seed) - 1) / speed(seed)
+        fallen, frame = (tick + (seed >> 8)).divmod(falling + SPLASH.length)
+        color = color(column, fallen)
+        return splash(cells, column, frame - falling, color) if frame >= falling
+
+        fall(cells, column, frame * speed(seed), color)
+      end
+
+      # A row or two a tick.
+      def speed(seed) = ((seed >> 4) % 2) + 1
+
+      # A colour each time the column's drop falls, from a checksum of how many times it has.
+      def color(column, fallen) = COLORS[Zlib.crc32("#{column} #{fallen}") % COLORS.length]
+
+      # The drop at the row, and its tail above it.
+      def fall(cells, column, row, color)
+        cells[row][column] = ['│', color]
+        cells[row - 1][column] = ['╎', color] if row.positive?
+      end
+
+      def splash(cells, column, frame, color)
+        spread, char = SPLASH[frame]
+        [column - spread, column + spread].uniq.each { cells[height - 1][it] = [char, color] if it.between?(0, width - 1) }
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/celebration/scene.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../../text'
+require_relative '../waffle/balloons'
+require_relative '../waffle/confetti'
+require_relative '../waffle/sparkles'
+require_relative 'fireworks'
+require_relative 'rain'
+
+module Raindown
+  module TUI
+    # Animations drawn over each other, each into the same cells, a character and its style each, in turn, so the later
+    # ones are on top, like Fireworks over the Rain.
+    class Scene
+      include Text
+
+      attr_reader :width, :height
+
+      def initialize(width:, height:, animations: [Rain, Fireworks])
+        @width = width
+        @height = height
+        @animations = animations.map { it.new(width:, height:) }
+      end
+
+      # The lines at the tick, as segments.
+      def lines(tick)
+        cells = Array.new(height) { Array.new(width) { [' ', :blank] } }
+        @animations.each { it.draw(cells, tick) }
+        cells.map { segments(it) }
+      end
+
+      private
+
+      # The row's runs of cells in the same style, a segment each.
+      def segments(row)
+        row.chunk_while { |cell, after| cell[1] == after[1] }.map { Segment.new(text: it.map(&:first).join, style: it[0][1], event: nil) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # The cells Code feelings' methods take in its grid, and how its cursor moves between them, along them and a row up
+    # or down.
+    module CellMoves
+      # Each cell's method, by its index, in reading order, in a grid as many cells across as the columns.
+      # They're kept, so up and down move a row.
+      # The first time the grid's drawn, with its rows, right after the view opens, the batch is picked to fill them, and
+      # again a while after the screen's resized, keeping the selected method where it's still in the batch.
+      def cells(columns, rows = nil)
+        was = selected
+        reselect(was) if rows && @week.fill(columns * rows)
+        @columns = columns
+        @cells = code_methods.each_with_index.flat_map { |method, index| [index] * method.size }
+      end
+
+      private
+
+      def move(by)
+        self.cursor = @cursor + by
+        nil
+      end
+
+      # To the method in the cell above or below the selected one's first cell.
+      def move_row(by)
+        cell = @cells[@cells.index(@cursor).to_i + (by * @columns)]
+        self.cursor = cell if cell
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+require 'zlib'
+
+module Raindown
+  module TUI
+    # A function or method in a project's code, to sort how it feels: where it is, its lines, how many commits changed
+    # its file, and how much it drifts, from 0 to 9, which is how it ranks among the project's by both of them.
+    CodeMethod = Data.define(:path, :owner, :name, :line, :lines, :changes, :drift) do
+      # Like Layout#lines, or lines alone outside a class or the like.
+      def label = [owner, name].compact.join('#')
+
+      # A cell for every few lines, up to 8.
+      def size = ((lines.length / 4) + 1).clamp(1, 8)
+
+      # What drift ranks: long methods in files that keep changing weigh most.
+      def weight = lines.length * (changes + 1)
+
+      # Its code's checksum, which changes when its code does, but not its indent, trailing spaces or blank lines.
+      def checksum = Zlib.crc32(lines.map(&:strip).reject(&:empty?).join("\n")).to_s(16)
+    end
+
+    # Every function and method in a project's code, in any language: from Universal Ctags when it's installed,
+    # which knows over 100 languages, or else from how the code's indented. Specs, tests, and folders a project
+    # doesn't write, like vendor, are left out.
+    module CodeMethods
+      SKIPPED = %w[.git spec test tests vendor tmp pkg node_modules].freeze
+      # The kinds Ctags gives functions and methods, across languages.
+      KINDS = %w[function method singletonMethod procedure subroutine func constructor].freeze
+      # The files the indentation fallback reads, by extension.
+      EXTENSIONS = %w[rb py js mjs ts tsx jsx go rs java kt swift c h cc cpp cs php ex exs lua sh scala].freeze
+      MODIFIERS = '(?:(?:export|default|async|static|public|private|protected|pub(?:\(\w+\))?|override|final)\s+)*'
+      # A line that starts a function, with its name, like "def area", "pub fn draw(" or "func (s *Square) Area(".
+      DEFINITION = /\A\s*#{MODIFIERS}(?:def|function|fn|func|sub|proc)\s+(?:\([^)]*\)\s*)?(?:self\.)?([\w?!=]+)/
+      # A line that starts a class or the like, with its name, which names the functions inside it.
+      OWNER = /\A\s*#{MODIFIERS}(?:class|module|struct|impl|interface|trait|object)\s+(\w+(?:::\w+)*)/
+      # A line that closes a block, at the indent of the line that opened it.
+      CLOSER = /\A\s*(?:end\b|[}\])])/
+
+      module_function
+
+      def list(root)
+        changes = file_changes(root)
+        drifting((tagged(root) || indented(root)).map { it.with(changes: changes.fetch(it.path, 0)) })
+      end
+
+      # Each method with its drift, from 0 for the lightest to 9 for the heaviest, where methods that weigh the same
+      # drift the same, so the digits spread out in any project, whatever its language or size.
+      def drifting(methods)
+        weights = methods.map(&:weight).sort
+        methods.map { |method| method.with(drift: weights.bsearch_index { it >= method.weight } * 9 / [weights.length - 1, 1].max) }
+      end
+
+      # From Universal Ctags, or nil when it isn't installed, or the ctags installed is another, without JSON.
+      def tagged(root)
+        json, status = Open3.capture2('ctags', '--output-format=json', '--fields=+ne', '-R', '-f', '-',
+                                      *SKIPPED.map { "--exclude=#{it}" }, '.', chdir: root, err: File::NULL)
+        return unless status.success?
+
+        sources = Hash.new { |hash, path| hash[path] = File.readlines(path, chomp: true) }
+        json.each_line.filter_map { tag_method(root, JSON.parse(it), sources) }.sort_by { [it.path, it.line] }
+      rescue SystemCallError, JSON::ParserError
+        nil
+      end
+
+      def tag_method(root, tag, sources)
+        return unless tag['_type'] == 'tag' && KINDS.include?(tag['kind']) && tag['end']
+
+        path = File.join(root, tag['path'].delete_prefix('./'))
+        lines = sources[path][(tag['line'] - 1)...tag['end']]
+        CodeMethod.new(path:, owner: tag['scope']&.split(/\.|::/)&.last, name: tag['name'], line: tag['line'], lines:, changes: 0, drift: 0)
+      end
+
+      def indented(root)
+        files(root).flat_map { indented_in(it) }
+      end
+
+      def files(root)
+        Dir.glob('**/*', File::FNM_DOTMATCH, base: root)
+           .select { EXTENSIONS.include?(File.extname(it).delete_prefix('.')) }
+           .reject { it.split('/').intersect?(SKIPPED) }.sort.map { File.join(root, it) }
+      end
+
+      # Each line that starts a function, to where the indent comes back to its own, named after the class it's in.
+      def indented_in(path)
+        lines = File.readlines(path, chomp: true)
+        lines.each_index.filter_map do |index|
+          name = lines[index][DEFINITION, 1]
+          next unless name
+
+          CodeMethod.new(path:, owner: owner_of(lines, index), name:, line: index + 1,
+                         lines: lines[index..block_end(lines, index)], changes: 0, drift: 0)
+        end
+      rescue SystemCallError, ArgumentError
+        []
+      end
+
+      # The block's last line: the last one indented further than its first, or the line closing it, like "end".
+      def block_end(lines, index)
+        start = indent(lines[index])
+        last = index
+        lines.each_with_index.drop(index + 1).each do |line, number|
+          next if line.strip.empty?
+          return number if indent(line) == start && line.match?(CLOSER)
+          return last if indent(line) <= start
+
+          last = number
+        end
+        last
+      end
+
+      # The class or the like that the line's inside, by the nearest line above that's indented less and starts one.
+      def owner_of(lines, index)
+        depth = indent(lines[index])
+        owner = lines[0...index].reverse_each.find { indent(it) < depth && it.match?(OWNER) }
+        owner && owner[OWNER, 1].split('::').last
+      end
+
+      def indent(line) = line[/\A\s*/].length
+
+      # How many commits changed each file, from git log, or none outside a repository.
+      def file_changes(root)
+        log, status = Open3.capture2('git', '-C', root, 'log', '--format=', '--name-only', '--relative', err: File::NULL)
+        return {} unless status.success?
+
+        log.split("\n").reject(&:empty?).tally.transform_keys { File.join(root, it) }
+      rescue SystemCallError
+        {}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../code_box'
+
+module Raindown
+  module TUI
+    # Code feelings' CodeBox below the grid: the selected method's code, where it is and how many commits changed its
+    # file, then why it felt that way while that's typed, below a line.
+    module FeelingsCodeBox
+      include CodeBox
+
+      private
+
+      def boxed_method = view.selected
+      def box_title(method) = "#{where(method)} · #{method.label}"
+      def box_note(method) = " changed #{method.changes}× ─"
+      def box_style = :feelings
+      def box_parts(method) = highlighted(method)
+
+      # As many lines as fit expanded, with the bins and a few of the grid's rows left above it.
+      def box_room = height - Bins::BIN_LINES - BOX_LINES - MIN_GRID_ROWS
+
+      def box_footer
+        return [] unless view.typing?
+
+        note_lines
+      end
+
+      # Why it felt that way, as it's typed, below a line, in as many lines as it takes.
+      def note_lines = [box_edge('├', '┤'), *hanging("Why #{view.noting.upcase}? > ", "#{view.note}▏").map { boxed([[it, :feelings]]) }]
+
+      # The text after the lead, wrapped to fit the box, with the lines after the first lined up under the text.
+      def hanging(lead, text)
+        indent = ' ' * display_width(lead)
+        lines = wrap(text, width - 6 - indent.length)
+        [lead, *Array.new(lines.length - 1, indent)].zip(lines).map(&:join)
+      end
+    end
+  end
+end