raindown 0.6.0 → 0.8.0

data/lib/raindown/tui/feelings/waffle/baked_waffle.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # A waffle's rows, as [text, style] parts: a grid of pockets between golden ridges, shaded darker at their tops,
+    # under the ridges, so they look deep, with rounded corners, and a pat of butter melting where the middle ridges cross,
+    # with a white shine at its top left, and as many of its pockets as have been filled with syrup, nearest the butter
+    # first:
+    #     ▄███████████████████████▄
+    #     █▓▓▓▓▓█▓▓▓▓▓█▓▓▓▓▓█▓▓▓▓▓█
+    #     █░░░░░█░░░░░█░░░░░█░░░░░█
+    #     █████████████████████████
+    #     █▓▓▓▓▓█▓▓▓▓▓█▓▓▓▓▓█▓▓▓▓▓█
+    #     █░░░░░█░░░▄▄▄▄▄░░░█░░░░░█
+    #     ██████████████████████████
+    module BakedWaffle
+      RIDGE = :code_number
+      POCKET = :bright_orange
+      BUTTER = :button
+      SHINE = :shine
+      SYRUP = :syrup
+      # The pockets across and down, the columns each takes, and the lines a pocket and a ridge take.
+      POCKETS = 4
+      POCKET_WIDTH = 5
+      ROW_LINES = 3
+      # The pat of butter's lines, from the line above the middle ridge, a drip below it, and the shine at its top left, as
+      # its lines and columns.
+      PAT = %w[▄▄▄▄▄ █████ ▀▀█▀▀].freeze
+      DRIP = '▀'
+      SHINE_AT = [[0, 0], [0, 1], [1, 0]].freeze
+
+      module_function
+
+      def rows(syrup: 0)
+        cells = Array.new(down) { |row| Array.new(across) { |column| cell(row, column, across, down) } }
+        buttered(sweetened(cells, syrup), down / 2, across / 2).map { parts(it) }
+      end
+
+      def across = 1 + (POCKETS * (POCKET_WIDTH + 1))
+      def down = 1 + (POCKETS * ROW_LINES)
+
+      # The cells with as many pockets filled with syrup, nearest the middle first, keeping their shading.
+      def sweetened(cells, filled)
+        pockets.first(filled).each do |pocket_row, pocket_column|
+          (1...ROW_LINES).to_a.product((1..POCKET_WIDTH).to_a).each do |line, offset|
+            cells[(pocket_row * ROW_LINES) + line][(pocket_column * (POCKET_WIDTH + 1)) + offset][1] = SYRUP
+          end
+        end
+        cells
+      end
+
+      # The pockets, by their row and column, nearest the middle first.
+      def pockets
+        middle = (POCKETS - 1) / 2.0
+        (0...POCKETS).to_a.product((0...POCKETS).to_a).sort_by { |row, column| [(row - middle).abs + (column - middle).abs, row, column] }
+      end
+
+      # A ridge, rounded at its corners, or a pocket, darker at its top, under the ridge above it, than below.
+      def cell(row, column, across, down)
+        edge = [0, down - 1].include?(row)
+        return [' ', :blank] if edge && [0, across - 1].include?(column)
+        return ['▄', RIDGE] if row.zero? && [1, across - 2].include?(column)
+        return ['▀', RIDGE] if edge && [1, across - 2].include?(column)
+        return ['█', RIDGE] if (row % ROW_LINES).zero? || (column % (POCKET_WIDTH + 1)).zero?
+
+        [%w[▓ ░][(row % ROW_LINES) - 1], POCKET]
+      end
+
+      # The cells with the pat of butter on the middle ridges' cross, its drip, and its shine.
+      def buttered(cells, row, column)
+        PAT.each_with_index do |line, at|
+          line.each_char.with_index { |char, offset| cells[row - 1 + at][column - 2 + offset] = [char, BUTTER] }
+        end
+        cells[row + 2][column] = [DRIP, BUTTER]
+        shine(cells, row, column)
+      end
+
+      # The cells with the butter's top left shining.
+      def shine(cells, row, column)
+        SHINE_AT.each { |line, offset| cells[row - 1 + line][column - 2 + offset][1] = SHINE }
+        cells
+      end
+
+      # The row's cells in runs of the same style, as [text, style] parts.
+      def parts(row) = row.chunk_while { |cell, after| cell[1] == after[1] }.map { [it.map(&:first).join, it[0][1]] }
+    end
+  end
+end

data/lib/raindown/tui/feelings/waffle/balloons.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+require_relative '../celebration/rain'
+
+module Raindown
+  module TUI
+    # Balloons floating up either side of the waffle, when a batch of code feelings is refined: one for every so many
+    # columns, left and right in turn, clear of the waffle in the middle, each in a bright colour, shaded where the light
+    # catches it, with a knot and a string that kinks, rising from below the bottom, swaying a column either way, then
+    # round again. Their spaces are see-through:
+    #     ▄███▄
+    #    █░▒████
+    #    █▒█████
+    #     ▀███▀
+    #       ▼
+    #       │
+    #       ╰╮
+    #        │
+    class Balloons
+      BALLOON = [' ▄███▄', '█░▒████', '█▒█████', ' ▀███▀', '   ▼'].freeze
+      STRING = ['   │', '   ╰╮', '    │'].freeze
+      # The columns for each balloon, and the frames each row it rises takes.
+      COLUMNS_A_BALLOON = 20
+      # The columns kept clear in the middle, for the waffle and its text.
+      MIDDLE = 39
+      RISE_FRAMES = 2.1
+      # Where a balloon is, by its left column and its top row, and its colour.
+      Balloon = Data.define(:left, :top, :color)
+
+      attr_reader :width, :height
+
+      def initialize(width:, height:)
+        @width = width
+        @height = height
+      end
+
+      # Draws the balloons where they've floated to by the tick into a Scene's cells.
+      def draw(cells, tick)
+        [width / COLUMNS_A_BALLOON, 2].max.times { balloon(cells, floated(it, Zlib.crc32("balloon #{it}"), tick)) }
+      end
+
+      private
+
+      # Where a balloon's floated to by the tick, from its seed, a checksum of it: where it rises in its side, when it starts,
+      # how it sways, never past an edge, and its colour.
+      def floated(number, seed, tick)
+        sway = (side(number, seed) + Math.sin((tick + seed) / 6.4).round).clamp(0, [width - BALLOON.map(&:length).max, 0].max)
+        Balloon.new(left: sway, top: risen(seed, tick),
+                    color: Rain::COLORS[(seed >> 16) % Rain::COLORS.length])
+      end
+
+      # A column in the left side for the even balloons, and the right for the odd, either side of the middle.
+      def side(number, seed)
+        room = [((width - MIDDLE) / 2) - BALLOON.map(&:length).max, 1].max
+        column = seed % room
+        return column if number.even?
+
+        width - room + column - BALLOON.map(&:length).max
+      end
+
+      # Its top row, a row higher every RISE_FRAMES, from below the bottom to above the top, then round again.
+      def risen(seed, tick) = height - 1 - (((tick / RISE_FRAMES).floor + (seed >> 8)) % (height + BALLOON.length + STRING.length))
+
+      def balloon(cells, balloon)
+        BALLOON.each_with_index { |text, row| put(cells, balloon.top + row, balloon.left, text, balloon.color) }
+        STRING.each_with_index { |text, row| put(cells, balloon.top + BALLOON.length + row, balloon.left, text, :border) }
+      end
+
+      # The text's characters from the left column, leaving the cells under its spaces as they are.
+      def put(cells, row, left, text, style)
+        return unless row.between?(0, height - 1)
+
+        text.each_char.with_index do |char, at|
+          cells[row][left + at] = [char, style] if char != ' ' && (left + at).between?(0, width - 1)
+        end
+      end
+    end
+  end
+end

data/lib/raindown/tui/feelings/waffle/confetti.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+require_relative '../celebration/rain'
+require_relative 'balloons'
+
+module Raindown
+  module TUI
+    # Confetti falling either side of the waffle, behind the balloons, when a batch of code feelings is refined: flecks in
+    # bright colours, a row or two lower each frame, as fast as the Rain, wavering a column either way, then round again
+    # from the top.
+    #    ▪    ◆
+    #       ·    ▴
+    class Confetti
+      FLECKS = %w[▪ ◆ ▴ ·].freeze
+      # The columns for each fleck, and the frames each column it wavers takes.
+      COLUMNS_A_FLECK = 3
+      WAVER_FRAMES = 11
+
+      attr_reader :width, :height
+
+      def initialize(width:, height:)
+        @width = width
+        @height = height
+      end
+
+      # Draws the confetti where it's drifted to by the tick into a Scene's cells, clear of the waffle in the middle.
+      def draw(cells, tick)
+        (width / COLUMNS_A_FLECK).times { fleck(cells, Zlib.crc32("confetti #{it}"), tick) }
+      end
+
+      private
+
+      def fleck(cells, seed, tick)
+        column = drifted(seed, tick)
+        return if clear?(column)
+
+        cells[((tick * speed(seed)) + (seed >> 8)) % height][column] = look(seed)
+      end
+
+      # A row or two a frame, like the Rain's drops.
+      def speed(seed) = ((seed >> 12) % 2) + 1
+
+      # Its column, wavering a column either way as it falls.
+      def drifted(seed, tick) = (seed % width) + (((tick / WAVER_FRAMES) + seed) % 3) - 1
+
+      # Whether the column's in the middle, kept clear for the waffle, or off the screen.
+      def clear?(column) = (column - (width / 2)).abs <= Balloons::MIDDLE / 2 || !column.between?(0, width - 1)
+
+      # Its fleck and colour.
+      def look(seed) = [FLECKS[(seed >> 4) % FLECKS.length], Rain::COLORS[(seed >> 16) % Rain::COLORS.length]]
+    end
+  end
+end

data/lib/raindown/tui/feelings/waffle/sparkles.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+require_relative 'baked_waffle'
+
+module Raindown
+  module TUI
+    # Sparkles twinkling around the waffle, when a batch of code feelings is refined: white, on a ring just clear of it,
+    # each growing from a dot to a star and back, then gone for a while, at its own time.
+    #      ·         ✦
+    #    ▄█████████████▄   ✧
+    class Sparkles
+      TWINKLE = %w[· ✧ ✦ ✧ ·].freeze
+      COUNT = 10
+      # The frames each of a twinkle's steps takes, and the steps between a sparkle's twinkles.
+      TWINKLE_FRAMES = 3
+      TWINKLE_EVERY = 16
+      # The columns and lines the ring's clear of the waffle by.
+      MARGIN = 3
+
+      attr_reader :width, :height
+
+      def initialize(width:, height:)
+        @width = width
+        @height = height
+      end
+
+      # Draws the sparkles twinkling by the tick into a Scene's cells.
+      def draw(cells, tick)
+        COUNT.times { sparkle(cells, Zlib.crc32("sparkle #{it}"), tick) }
+      end
+
+      private
+
+      def sparkle(cells, seed, tick)
+        char = TWINKLE[((tick / TWINKLE_FRAMES) + seed) % TWINKLE_EVERY]
+        row, column = spot(seed)
+        cells[row][column] = [char, :shine] if char && row.between?(0, height - 1) && column.between?(0, width - 1)
+      end
+
+      def spot(seed) = ring[seed % ring.length]
+
+      # The spots on a ring just clear of the waffle, in the middle of the screen, by their row and column: along its top
+      # and bottom, and down its sides.
+      def ring
+        @ring ||= begin
+          top, left, bottom, right = corners
+          [*(left..right).flat_map { [[top, it], [bottom, it]] }, *((top + 1)...bottom).flat_map { [[it, left], [it, right]] }]
+        end
+      end
+
+      # The ring's top row, left column, bottom row and right column, MARGIN clear of the waffle.
+      def corners
+        left = (width - BakedWaffle.across) / 2 - MARGIN
+        top = ((height - BakedWaffle.down) / 2) - MARGIN + 1
+        [top, left, top + BakedWaffle.down + MARGIN, left + BakedWaffle.across + (MARGIN * 2) - 1]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'baked_waffle'
+
+module Raindown
+  module TUI
+    # The waffle after the rain, between balloons floating up, when a batch of code is refined, and the week's work is
+    # done: a BakedWaffle, then a blank line, then what's been done. Once it's popped, syrup pours onto its butter, then
+    # fills its pockets.
+    module Waffle
+      TEXT = [[], [['100% refined', :feelings]], [['The work is mysterious and important.', :feelings]]].freeze
+      # The row the waffle pops out from, its butter's on the middle ridge, and the frames each row more above and below
+      # it takes, half a second at the Screen's 20 frames a second while it celebrates.
+      BUTTER_ROW = BakedWaffle::POCKETS * BakedWaffle::ROW_LINES / 2
+      POP_FRAMES = 10
+      # The frames until it's all popped, and then the frames each pocket takes to fill with syrup, once it's poured.
+      POPPED_FRAMES = POP_FRAMES * (BakedWaffle.down + TEXT.length - 1 - BUTTER_ROW)
+      FILL_FRAMES = 10
+
+      private
+
+      # The waffle over the lines, as it pops, by the frames since the rain stopped: the butter's row first, then a row
+      # more above and below it every POP_FRAMES, then its lines of text, and then the syrup.
+      def waffle(lines, frame)
+        top = waffle_top
+        [*BakedWaffle.rows(syrup: filled(frame, top)), *TEXT].each_with_index do |parts, row|
+          next unless popped?(parts, row, frame) && lines[top + row]
+
+          lines[top + row] = over(lines[top + row], parts)
+        end
+        pour(lines, frame, top)
+      end
+
+      def waffle_top = [(height - BakedWaffle.down - TEXT.length) / 2, 0].max
+
+      def popped?(parts, row, frame) = parts.any? && (row - BUTTER_ROW).abs <= frame / POP_FRAMES
+
+      # The syrup's stream, falling a line a frame from the top onto the butter, once it's all popped, until every
+      # pocket's filled.
+      def pour(lines, frame, top)
+        poured = frame - POPPED_FRAMES
+        return lines if poured.negative? || filled(frame, top) >= BakedWaffle::POCKETS**2
+
+        [poured, stream(top)].min.times { lines[it] = overlay_segments(lines[it], [segment('│', :syrup, width: 1)], column: stream_column) }
+        lines
+      end
+
+      # The lines from the top down to the butter, and the column of the waffle's middle, which the syrup falls down.
+      def stream(top) = top + BUTTER_ROW - 1
+      def stream_column = ((width - BakedWaffle.across - 2) / 2) + 1 + (BakedWaffle.across / 2)
+
+      # The pockets filled with syrup by the frame, one every FILL_FRAMES once the stream's reached the butter.
+      def filled(frame, top) = [(frame - POPPED_FRAMES - stream(top)) / FILL_FRAMES, 0].max
+
+      # The parts over the middle of the line, with a space either side, so they're clear of the balloons behind them.
+      def over(line, parts)
+        segments = [[' ', :blank], *parts, [' ', :blank]].map { |text, style| segment(text, style, width: display_width(text)) }
+        overlay_segments(line, segments, column: [(width - segments.sum { display_width(it.text) }) / 2, 0].max)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'batch'
+
+module Raindown
+  module TUI
+    # This week's Batch of a project's code to feel, picked to fill the grid when the view first opens and draws it,
+    # then kept through reloads, like after a method's edited or fixed, until the screen's resized.
+    class WeeklyBatch
+      # How long a resized grid keeps its new number of cells before the batch is picked again to fill it, so it isn't
+      # picked for every size the screen passes through while it's dragged.
+      RESIZE_SECONDS = 2
+
+      attr_reader :batch
+
+      def initialize(log:)
+        @log = log
+        @batch = Batch.new(files: [], code_methods: [], log:, week: Batch.this_week)
+      end
+
+      # The methods read again, keeping the batch's files.
+      def read(every)
+        @every = every
+        @batch = batch.reading(every)
+      end
+
+      # Picks the batch to fill the grid's cells, once they're known, and again once a resized grid's kept its new number
+      # of them for RESIZE_SECONDS, and returns whether it did.
+      def fill(grid_cells, now: Process.clock_gettime(Process::CLOCK_MONOTONIC))
+        return refill(grid_cells) unless @filled_for
+
+        @resizing = nil unless @resizing&.first == grid_cells
+        return false if grid_cells == @filled_for
+
+        @resizing ||= [grid_cells, now]
+        return false if now - @resizing.last < RESIZE_SECONDS
+
+        refill(grid_cells)
+      end
+
+      private
+
+      def refill(grid_cells)
+        @filled_for = grid_cells
+        @resizing = nil
+        @batch = Batch.pick(@every, log: @log, cells: grid_cells)
+        true
+      end
+    end
+  end
+end

data/lib/raindown/tui/file_tree.rb

@@ -58,8 +58,6 @@ module Raindown
         path.delete_prefix(File.join(base, ''))
       end
 
-      private
-
       # A scope's own files, without those of the projects inside it, which are projects of their own.
       def files
         return @files unless scope
@@ -67,6 +65,8 @@ module Raindown
         @files.select { |path| owner(path) == scope }
       end
 
+      private
+
       def owner(path)
         [root, *@projects].select { path.start_with?(File.join(it, '')) }.max_by(&:length)
       end
@@ -85,12 +85,13 @@ module Raindown
       # A folder, and the tree inside it unless it's folded.
       def folder_rows(name, children, prefix, depth)
         folder = File.join(base, prefix, name)
-        folded = !@expanded.include?(folder)
+        expanded = @expanded.include?(folder)
         project = @projects.include?(folder)
-        row = Row.new(text: "#{folded ? '▸' : '▾'} #{"#{PROJECT} " if project}#{name}/", depth:,
+        row = Row.new(text: [expanded ? '▾' : '▸', (PROJECT if project), "#{name}/"].compact.join(' '), depth:,
                       kind: project ? :project : :folder, target: folder, fold: -> { toggle(folder) })
+        return [row] unless expanded
 
-        [row, *(tree_rows(children, File.join(prefix, name), depth + 1) unless folded)]
+        [row, *tree_rows(children, File.join(prefix, name), depth + 1)]
       end
     end
   end

data/lib/raindown/tui/highlighter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # Code coloured with Rouge, which knows over 200 languages, as each line's [text, style] parts. Each part's style is
+    # the kind of token it is, like a keyword or a string, from the few code styles Styles has, so they work in any
+    # terminal. Code in a language Rouge doesn't know is a plain part a line.
+    module Highlighter
+      # Each kind of token's style, by the start of its name, like Literal.String.Double for a string, most specific first.
+      STYLES = [['Name.Function', :code_function], ['Name.Class', :code_constant], ['Name.Constant', :code_constant],
+                ['Name.Builtin', :code_constant], ['Name.Label', :code_constant], ['Keyword', :code_keyword],
+                ['Literal.String', :code_string], ['Literal.Number', :code_number], ['Comment', :code_comment]].freeze
+
+      module_function
+
+      # The lines highlighted for a file's name, like shapes.rb, or a code fence's language, like json. Markdown
+      # highlights the code in its fences in their own languages, like an endpoint's request and response.
+      def lines(lines, filename: nil, language: nil)
+        lexer = lexer(filename:, language:)
+        return lines.map { [[it, :code]] } unless lexer
+
+        lexer.lex(lines.join("\n")).each_with_object([[]]) do |(token, text), highlighted|
+          text.split(/(\n)/).each do |piece|
+            next highlighted << [] if piece == "\n"
+
+            highlighted.last << [piece, style(token)] unless piece.empty?
+          end
+        end
+      end
+
+      # Rouge takes about a third of a second to load, so the TUI loads it when it starts, rather than with its code.
+      def lexer(filename:, language:)
+        require 'rouge'
+        lexer = Rouge::Lexer.find_fancy(language) unless language.to_s.empty?
+        lexer ||= Rouge::Lexer.guess_by_filename(filename).new if filename
+        lexer unless lexer.is_a?(Rouge::Lexers::PlainText)
+      end
+
+      def style(token)
+        name = token.qualname
+        STYLES.find { |prefix, _| name.start_with?(prefix) }&.last || :code
+      end
+    end
+  end
+end

data/lib/raindown/tui/layout.rb

@@ -3,6 +3,8 @@
 require_relative 'events'
 require_relative 'text'
 require_relative 'title'
+require_relative 'project_box'
+require_relative 'search_box'
 
 module Raindown
   module TUI
@@ -14,9 +16,9 @@ module Raindown
     #    ┌─ Layout ──────────────────────────────────────────────────┐
     #    │  Raindown  ~/docs › guides/setup.md                       │
     #    │ ┌─ nav pane ──────┐ ┌─ main pane ───────────────────────┐ │
-    #    │ │ Dashboard       ▏ # Setup                             │ │
-    #    │ │ ▾ guides/       ▏   toc: [+3]                         │ │
-    #    │ │   setup.md      ▏   ## Install                        │ │
+    #    │ │ Dashboard       │ # Setup                             │ │
+    #    │ │ ▾ guides/       │   toc: [+3]                         │ │
+    #    │ │   setup.md      │   ## Install                        │ │
     #    │ └─ ListRenderer ──┘ └─ view.renderer ───────────────────┘ │
     #    │  Opened guides/setup.md                                   │
     #    │  Tab Pane  Enter Open  X Run  E dit  W rite back  Q uit   │
@@ -27,9 +29,12 @@ module Raindown
       include Title
 
       NAV_WIDTH = (16..32)
-      # The line between the nav and main panes, at its column's left edge, unlike │ in the middle,
-      # so a highlighted file's row runs up to it.
-      DIVIDER = '▏'
+      # The line between the nav and main panes, and the line beneath the title, along the line above the panes, in the
+      # middle of their rows and columns, joined where they meet, like a box's lines. The divider is never highlighted,
+      # so a highlighted row stops at the edge of its column.
+      DIVIDER = '│'
+      BORDER = '─'
+      JOIN = '┬'
       # The title, status and button lines.
       CHROME_HEIGHT = 3
 
@@ -44,11 +49,7 @@ module Raindown
       def lines
         return [status].first(height) if height < CHROME_HEIGHT + 1
 
-        lines = [title, *panes, status, button_bar]
-        return lines unless navigator.menu
-
-        require_relative 'menu_overlay'
-        MenuOverlay.new(navigator, width:, column: display_width(name)).apply(lines)
+        overlaid([title, *panes, status, button_bar])
       end
 
       # A third of the width, within NAV_WIDTH, and never more than half of a narrow screen.
@@ -58,6 +59,14 @@ module Raindown
 
       private
 
+      # The project menu or Teleport, drawn over the lines while it's open.
+      def overlaid(lines)
+        return ProjectBox.new(navigator, width:, column: display_width(name)).apply(lines) if navigator.menu
+        return SearchBox.new(navigator, width:).apply(lines) if navigator.teleporting?
+
+        lines
+      end
+
       def body_height = height - CHROME_HEIGHT
 
       # Below a blank line for spacing, the nav pane beside the main pane, each drawn by the renderer of what's in it.
@@ -65,16 +74,19 @@ module Raindown
         nav = renderer_in(:nav, nav_width).lines
         main = view_renderer.lines
 
-        [spacer, *Array.new(body_height - 1) { |index| [*nav[index], divider(main[index]), *main[index]] }]
+        [spacer, *Array.new(body_height - 1) { |index| [*nav[index], segment(DIVIDER, :divider, width: 1), *main[index]] }]
+      end
+
+      # A line above the panes, the border beneath the title, but for what the main pane's renderer puts in its side of it.
+      def spacer
+        [border(segment('', :blank, width: nav_width)), segment(JOIN, :divider, width: 1), *view_renderer.spacer.map { border(it) }]
       end
 
-      # A blank line above the panes, for spacing.
-      def spacer = [segment('', :blank, width: nav_width), divider([]), segment('', :blank, width: width - nav_width - 1)]
+      # A blank segment of the line above the panes as the border, in the divider's colour.
+      def border(segment)
+        return segment unless segment.style == :blank
 
-      # The divider is on the background of the outline's row beside it, when that's highlighted, so they meet.
-      def divider(main_line)
-        style = { selected: :selected_divider, cursor: :cursor_divider }.fetch(main_line.first&.style, :divider)
-        segment(DIVIDER, style, width: 1)
+        segment.with(text: segment.text.tr(' ', BORDER), style: :divider)
       end
 
       def view_renderer
@@ -121,4 +133,6 @@ end
 require_relative 'renderers/list_renderer'
 require_relative 'renderers/outline_renderer'
 require_relative 'renderers/dashboard_renderer'
+require_relative 'blueprints/blueprints_renderer'
 require_relative 'renderers/endpoint_renderer'
+require_relative 'feelings/feelings_renderer'

data/lib/raindown/tui/navigator/commands.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 require_relative '../../actions'
+require_relative '../../watcher/changes'
 
 module Raindown
   module TUI
-    # What a Navigator does to the open file: run an endpoint, open the editor, write back and read it again.
+    # What a Navigator does to the open file: run an endpoint, open the editor, write back and read it again,
+    # and to a feeling about some code: draw the page it was noted down in, or ask Claude Code to fix the code.
     # Each sets the status, so the Screen shows how it went, and returns what the Screen should do next, if anything.
     module Commands
       def run(file, line, name) = Wait.new(message: "Running #{name}...", task: -> { run_endpoint(file, line) })
@@ -15,8 +17,20 @@ module Raindown
         Run.new(command: Actions.edit_command(file, line:))
       end
 
+      def felt(feeling) = info("Felt #{feeling.temper} about #{feeling.method.label}")
+
+      # Leaves the screen for Claude Code, asked to fix the method, and the view reads the code again after.
+      def fix_with_agent(feeling)
+        return error('Install Claude Code, the claude command, to fix code with X') unless claude?
+
+        @edited = feeling.method.path
+        Run.new(command: ['claude', feeling.prompt])
+      end
+
       private
 
+      def claude? = ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).any? { File.executable?(File.join(it, 'claude')) }
+
       # Runs the endpoint selected in the outline, or listed below the files. One opened beside them runs itself.
       def execute
         target = selected&.target
@@ -64,12 +78,42 @@ module Raindown
         info('Reloaded')
       end
 
-      # Reads the file again when it's changed, like when it's saved in an editor or a watcher writes back to it.
+      # Writes back the files saved since the last tick, like when they're watched, then reads the open file again when
+      # it's changed, like when it's saved in an editor or written back to.
       def refresh
+        effect = watched(@saves.take) if @saves
         view.load if view.changed?
+        effect
+      end
+
+      # A change to a project's nodes loads them again, and a saved Markdown file's written back, like when it's watched,
+      # and the files and endpoints are read again for the files added, removed or changed. When endpoints run as files
+      # are written back, like with -x, the screen says so while they do, as they can take a while.
+      def watched(paths)
+        changes = Watcher.changes(paths, root:)
+        return reload if changes.any?(&:nodes?)
+        return if changes.empty?
+
+        saved = changes.select(&:saved?).map(&:path)
+        return write_back_all(saved) unless @runs_endpoints && saved.any?
+
+        Wait.new(message: "Writing back #{relative(saved.first)}...", task: -> { write_back_all(saved) })
+      end
+
+      def write_back_all(files)
+        files.each { write_back_saved(it) }
+        @files.load
+        @endpoints.load
         nil
       end
 
+      # A saved file's written back, saying so only when it's changed, as when it's watched.
+      def write_back_saved(file)
+        info("Updated #{relative(file)}") if @workers.for(file).call(:write_back, file)
+      rescue StandardError => e
+        error("#{relative(file)}: #{e.message}")
+      end
+
       def info(message)
         @status = [:info, message]
         nil