raindown 0.6.0 → 0.7.0

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # The waffle after the rain with a pat of butter, when a batch of code is refined, and the week's work is done:
+    #    ╔═══╦═══╦═══╦═══╦═══╗
+    #    ║   ║   ║   ║   ║   ║
+    #    ╠═══╬═══╬═══╬═══╬═══╣
+    #    ║   ║   ║███║   ║   ║
+    #    ╠═══╬═══╬═══╬═══╬═══╣
+    #    ║   ║   ║   ║   ║   ║
+    #    ╚═══╩═══╩═══╩═══╩═══╝
+    module Waffle
+      EDGE = :code_number
+      BUTTER = :button
+      WAFFLE = [
+        [['╔═══╦═══╦═══╦═══╦═══╗', EDGE]],
+        [['║   ║   ║   ║   ║   ║', EDGE]],
+        [['╠═══╬═══╬═══╬═══╬═══╣', EDGE]],
+        [['║   ║   ║', EDGE], ['███', BUTTER], ['║   ║   ║', EDGE]],
+        [['╠═══╬═══╬═══╬═══╬═══╣', EDGE]],
+        [['║   ║   ║   ║   ║   ║', EDGE]],
+        [['╚═══╩═══╩═══╩═══╩═══╝', EDGE]],
+        [['100% refined', :feelings]],
+        [['The work is mysterious and important.', :feelings]]
+      ].freeze
+
+      private
+
+      def waffle
+        top = [(height - WAFFLE.length) / 2, 0].max
+        lines = [*Array.new(top, []), *WAFFLE, *Array.new(height, [])].first(height)
+        lines.map { centred(it) }
+      end
+
+      # The parts in the middle of the width.
+      def centred(parts)
+        left = [(width - parts.sum { display_width(it[0]) }) / 2, 0].max
+        padded([segment('', :blank, width: left), *parts.map { |text, style| segment(text, style, width: display_width(text)) }])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# 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.
+    class WeeklyBatch
+      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.
+      def fill(grid_cells)
+        return if @filled
+
+        @filled = true
+        @batch = Batch.pick(@every, log: @log, cells: grid_cells)
+      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 'menu_overlay'
+require_relative 'search_overlay'
 
 module Raindown
   module TUI
@@ -44,11 +46,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 +56,14 @@ module Raindown
 
       private
 
+      # The project menu or the search, drawn over the lines while it's open.
+      def overlaid(lines)
+        return MenuOverlay.new(navigator, width:, column: display_width(name)).apply(lines) if navigator.menu
+        return SearchOverlay.new(navigator, width:).apply(lines) if navigator.searching?
+
+        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.
@@ -68,8 +74,8 @@ module Raindown
         [spacer, *Array.new(body_height - 1) { |index| [*nav[index], divider(main[index]), *main[index]] }]
       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 line above the panes, for spacing, blank but for what the main pane's renderer puts in its side of it.
+      def spacer = [segment('', :blank, width: nav_width), divider([]), *view_renderer.spacer]
 
       # The divider is on the background of the outline's row beside it, when that's highlighted, so they meet.
       def divider(main_line)
@@ -122,3 +128,4 @@ require_relative 'renderers/list_renderer'
 require_relative 'renderers/outline_renderer'
 require_relative 'renderers/dashboard_renderer'
 require_relative 'renderers/endpoint_renderer'
+require_relative 'feelings/feelings_renderer'

data/lib/raindown/tui/menu_overlay.rb

@@ -5,7 +5,7 @@ require_relative 'text'
 module Raindown
   module TUI
     # The project menu, drawn over the screen's lines in a box below the header's path:
-    #    🌧 Raindown  ~/dev ▾ › Dashboard
+    #    🌧  Raindown  ~/dev ▾ › Dashboard
     #                 ┌──────────────────────┐
     #                 │ All projects       ✓ │
     #                 │ ~/dev/raindown       │

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

@@ -4,7 +4,8 @@ require_relative '../../actions'
 
 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 +16,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

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

@@ -8,6 +8,7 @@ require_relative '../events'
 require_relative '../views/outline_view'
 require_relative '../views/list_view'
 require_relative 'project_menu'
+require_relative 'search'
 require_relative 'views'
 require_relative '../workers/workers'
 
@@ -20,20 +21,26 @@ module Raindown
       include Commands
       include Views
       include ProjectMenu
+      include Search
       include Focus
 
       # Keys of the events that move the cursor or the focus, and those that act on what's selected.
       MOVES = { up: -1, down: 1 }.freeze
       PANES = { tab: nil, left: :nav, right: :main }.freeze
       ACTIONS = { execute: :execute, edit: :edit, write_back: :write_back, reload: :reload, tick: :refresh }.freeze
+      # Keys that open the search, the project menu, the Dashboard or Code feelings, from anywhere.
+      OPENERS = { search: :open_search, projects: :toggle_menu, dashboard: :toggle_dashboard, feelings: :open_feelings }.freeze
 
       attr_reader :focus, :status
+      # What the mouse is over, which a click there would send, like a Click on a method's cells, or nil.
+      attr_reader :hovered
 
       def initialize(root:, path: nil, workers: Workers.new(root:))
         @workers = workers
         @files = FileTree.new(root:, workers:)
         @endpoints = Endpoints.new(workers:)
         @dashboard = DashboardView.new(root:, workers:)
+        @feelings = FeelingsView.new(root:)
         @nav = ListView.new { nav_rows }
         first = Projects.files(root, nested: true).first
         # The dashboard is the first page, unless a file is asked for, and "d" goes from it to the first file.
@@ -46,13 +53,17 @@ module Raindown
         case event
         when nil then nil
         when Click then click(event)
+        when Type then type(event)
+        when Hover then hover(event)
         else route(event)
         end
       end
 
-      # After the editor closes, the file is written back, like a save while it's watched, and read again.
+      # After the editor closes, a Markdown file is written back, like a save while it's watched, and read again.
+      # Other files, like code that was felt, aren't written back, and the view reads them again.
       def ran
-        write_back(@edited)
+        write_back(@edited) if @files.files.include?(@edited)
+        view.load
         @endpoints.load
       end
 
@@ -62,16 +73,34 @@ module Raindown
       # The folder the files are shown from: the chosen project's, or the root's.
       def base = @files.base
 
+      # While the search, or the view, like a feeling's note, takes what's typed, rather than keys' events.
+      def typing? = searching? || view.typing?
+
+      # While the view wants drawing faster than the ticks, like Code feelings' rain.
+      def animating? = view.animating?
+
       # What's in a pane: the nav's ListView on the left, or the view on the right, which keeps its own cursor.
       def content(pane) = pane == :nav ? @nav : view
 
       private
 
+      def hover(hover)
+        @hovered = hover.target
+        nil
+      end
+
+      # A typed character goes to the search, or to the view while it's typing.
+      def type(event)
+        return type_query(query + event.text) if searching?
+
+        view.next_step(event)&.take(self) if view.typing?
+      end
+
       def route(name)
         return :quit if name == :quit
+        return search_event(name) if searching?
         return menu_event(name) if menu
-        return toggle_menu if name == :projects
-        return toggle_dashboard if name == :dashboard
+        return send(OPENERS[name]) if OPENERS.key?(name)
         return view.next_step(name)&.take(self) if @focus == :main && view.next_step?(name)
 
         browser_event(name)
@@ -79,9 +108,10 @@ module Raindown
 
       # A click moves the cursor where it's clicked, and does the click's action there, like a key, unless that would
       # leave the terminal UI, like for the editor, so a stray click only moves the cursor.
-      # While the project menu's open, only its projects are clicked.
+      # While the project menu or the search is open, only its items are clicked.
       def click(click)
         return if menu && click.pane != :menu
+        return if searching? && click.pane != :search
 
         point(click)
         effect = route(click.action)
@@ -90,6 +120,7 @@ module Raindown
 
       def point(click)
         return @menu = click.index if click.pane == :menu
+        return @match = click.index if click.pane == :search
 
         content(click.pane).cursor = click.index
         @focus = click.pane
@@ -103,11 +134,13 @@ module Raindown
         send(ACTIONS[name]) if ACTIONS.key?(name)
       end
 
-      # The Dashboard, which every terminal draws two columns wide, then the files and the endpoints,
-      # with a blank line between each section that has rows.
+      # The Dashboard and Code feelings, whose emoji every terminal draws two columns wide, then the files and the
+      # endpoints, with a blank line between each section that has rows.
       def nav_rows
-        dashboard_row = Row.new(text: '📊 Dashboard', depth: 0, kind: :dashboard, target: dashboard, open: OpenView.new(view: dashboard))
-        [[dashboard_row], @files.rows, @endpoints.rows].reject(&:empty?).flat_map { [Row::SEPARATOR, *it] }.drop(1)
+        pages = { '📊 Dashboard' => dashboard, '🎭 Feelings' => feelings }.map do |text, view|
+          Row.new(text:, depth: 0, kind: :page, target: view, open: OpenView.new(view:))
+        end
+        [pages, @files.rows, @endpoints.rows].reject(&:empty?).flat_map { [Row::SEPARATOR, *it] }.drop(1)
       end
 
       def selected

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative '../events'
+require_relative '../views/endpoint_view'
+require_relative '../workers/worker'
+
+module Raindown
+  module TUI
+    # Teleport: "/" opens a search of the Dashboard, Code feelings, every file, heading and directive in the files, and every endpoint,
+    # matched as it's typed by letters in order, so "stp" finds "## Setup". Up and down move between the matches,
+    # Enter or a click opens the one selected, and Esc closes it. Other keys and clicks do nothing while it's open.
+    module Search
+      # The most matches it shows.
+      LIMIT = 10
+
+      # A place to teleport to: its text, where it is, like "guides/setup.md:12", and the step that opens it.
+      Place = Data.define(:text, :where, :open) do
+        # How well the query matches, or nil when it doesn't: in the text alone, which ranks above a match that needs
+        # where it is too, like "setup notes" for "## Setup" in notes.md.
+        def score(query)
+          in_text = letters_score(text, query)
+          return in_text + query.length if in_text
+
+          letters_score("#{text} #{where}", query)
+        end
+
+        private
+
+        # How well the query's letters appear in order in the text, ignoring case: higher for runs of them and for
+        # the starts of words, or nil when they don't all appear.
+        def letters_score(text, query)
+          haystack = text.downcase
+          last = -1
+          score = 0
+          query.downcase.each_char do |char|
+            index = haystack.index(char, last + 1)
+            return nil unless index
+
+            score += 1
+            score += 2 if index == last + 1
+            score += 2 if index.zero? || haystack[index - 1].match?(%r{[\s/#:._-]})
+            last = index
+          end
+          score
+        end
+      end
+
+      # What's typed, while the search is open, and the selected match.
+      attr_reader :query, :match
+
+      def searching? = !query.nil?
+
+      # The places that match what's typed, best first, then in the order they're in the files.
+      def matches
+        @places.each_with_index.filter_map { |place, index| (score = place.score(query)) && [-score, index, place] }
+               .min(LIMIT).map(&:last)
+      end
+
+      private
+
+      def open_search
+        @places = places
+        @match = 0
+        @query = ''
+        nil
+      end
+
+      def search_event(name)
+        case name
+        when :up, :down then move_match(name == :up ? -1 : 1)
+        when :enter then teleport
+        when :escape then close_search
+        when :backspace then type_query(query[0...-1])
+        end
+      end
+
+      def type_query(query)
+        @query = query
+        @match = 0
+        nil
+      end
+
+      def move_match(by)
+        @match = (@match + by).clamp(0, [matches.length - 1, 0].max)
+        nil
+      end
+
+      def teleport
+        place = matches[@match]
+        close_search
+        place&.open&.take(self)
+      end
+
+      def close_search
+        @query = nil
+        nil
+      end
+
+      def places
+        [Place.new(text: 'Dashboard', where: '', open: OpenView.new(view: dashboard)),
+         Place.new(text: 'Code feelings', where: '', open: OpenView.new(view: feelings)),
+         *@files.files.flat_map { file_places(it) },
+         *@endpoints.all.map { Place.new(text: it.text, where: "#{relative(it.path)}:#{it.line}", open: open_endpoint(it)) }]
+      end
+
+      # The file, then its headings and directives, in the order they're in it.
+      def file_places(path)
+        outline = @workers.for(path).call(:outline, path)
+        where = relative(path)
+        items = (outline.headings + outline.directives).sort_by(&:line)
+        [Place.new(text: where, where: '', open: Open.new(path:, line: nil)),
+         *items.map { Place.new(text: item_text(it), where: "#{where}:#{it.line}", open: Open.new(path:, line: it.line)) }]
+      rescue Worker::Error
+        []
+      end
+
+      def item_text(item)
+        return "#{'#' * item.level} #{item.text}" if item.is_a?(Document::Heading)
+
+        "#{item.name}: #{item.args}".strip
+      end
+
+      def open_endpoint(endpoint) = OpenView.new(view: EndpointView.new(endpoint, workers: @workers))
+    end
+  end
+end

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

@@ -2,6 +2,7 @@
 
 require_relative '../views/dashboard_view'
 require_relative '../views/endpoint_view'
+require_relative '../feelings/feelings_view'
 require_relative '../views/outline_view'
 
 module Raindown
@@ -11,7 +12,7 @@ module Raindown
     # A view has the pane that draws it, a next step for the keys it takes while it has the focus, and a target,
     # what's opened it in the files. It loads when it's opened, and again after a change.
     module Views
-      attr_reader :view, :dashboard
+      attr_reader :view, :dashboard, :feelings
 
       # The path of the file the view shows, if any.
       def path = view.path
@@ -27,17 +28,19 @@ module Raindown
         nil
       end
 
-      # Opens the file in the outline, on the directive at the line.
+      # Opens the file in the outline, on the heading or directive at the line.
       def open_at(path, line)
         path = File.expand_path(path)
         @files.reveal(path)
         open_view(OutlineView.new(path, workers: @workers))
-        view.cursor = view.rows.index { it.kind == :directive && it.target.line == line } || 0
+        view.cursor = view.rows.index { %i[heading directive].include?(it.kind) && it.target.line == line } || 0
         nil
       end
 
       private
 
+      def open_feelings = open_view(feelings)
+
       # Switches between the dashboard and the view before it.
       def toggle_dashboard
         return open_view(@previous) if view == dashboard && @previous

data/lib/raindown/tui/renderers/dashboard_renderer.rb

@@ -15,14 +15,14 @@ module Raindown
     #    ╰─────────────────────────────╯  ╰────────────────────────────────╯
     class DashboardRenderer < Renderer
       BUTTONS = [['Tab', 'Pane', :tab], ['Enter', 'Open', :enter], ['e', 'Edit', :edit], ['r', 'Reload', :reload],
-                 ['q', 'Quit', :quit]].freeze
+                 ['/', 'Search', :search], ['q', 'Quit', :quit]].freeze
       PROJECTS_BUTTON = ['p', 'Projects', :projects].freeze
 
       # Room for the project menu's button, when there's more than one project.
       def buttons
-        if navigator.projects? then BUTTONS.dup.insert(3, PROJECTS_BUTTON)
-        else BUTTONS
-        end
+        return BUTTONS unless navigator.projects?
+
+        BUTTONS.dup.insert(3, PROJECTS_BUTTON)
       end
 
       def page = 'Dashboard'

data/lib/raindown/tui/renderers/endpoint_renderer.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative '../highlighter'
 require_relative 'renderer'
 require_relative 'outline_renderer'
 
@@ -8,7 +9,7 @@ module Raindown
     # An endpoint opened from the files, right of them: its URL in a bar with rounded corners, and a button to run it,
     # then its response:
     #    ╭──────────────────────────────────────────╮
-    #    │ GET https://httpbin.org/uuid     [ Run ] │
+    #    │ GET https://httpbin.org/uuid       [Run] │
     #    ╰──────────────────────────────────────────╯
     #
     #    Response · json · fetched 2026-10-26
@@ -16,7 +17,7 @@ module Raindown
     #      "uuid": "48024974-f1b1-431a-a0cf-5cac0099a1a5"
     #    }
     class EndpointRenderer < Renderer
-      RUN = '[ Run ]'
+      RUN = '[Run]'
       RUN_WIDTH = RUN.length
       BUTTONS = OutlineRenderer::BUTTONS.reject { it.last == :write_back }.freeze
 
@@ -35,9 +36,12 @@ module Raindown
       # A click on the response moves the focus to it, to scroll it.
       def focus = Click.new(pane:, index: 0, action: :focus)
 
+      # The response's lines that fit, highlighted in the language of its code block, like json.
       def response(view, lines)
-        texts = view.visible([lines, 0].max)
-        Array.new([lines, 0].max) { [segment(texts[it] ? " #{texts[it]}" : '', :response, width:, event: focus)] }
+        code = Highlighter.lines(view.visible([lines, 0].max), language: view.language)
+        Array.new([lines, 0].max) do |line|
+          [segment(' ', :response, width: 1, event: focus), *code_segments(code[line] || [], width - 1, event: focus)]
+        end
       end
 
       # The bar is a column in from each side of the pane, with the URL and the button inside its border.
@@ -57,7 +61,7 @@ module Raindown
          run_button, segment(' │', :border, width: 2)]
       end
 
-      def run_button = segment(RUN, :run, width: RUN_WIDTH, event: Click.new(pane:, index: 0, action: :execute))
+      def run_button = segment(RUN, :button, width: RUN_WIDTH, event: Click.new(pane:, index: 0, action: :execute))
 
       def edge(left, right, inner)
         padded([margin, segment("#{left}#{'─' * (inner + 2)}#{right}", :border, width: inner + 4)])
@@ -66,11 +70,11 @@ module Raindown
       def margin = segment('', :blank, width: 1)
 
       def about(view)
-        text = if view.error then view.error
-               elsif view.response.empty? then 'No response yet. X runs the request.'
-               else ['Response', view.language, ("fetched #{view.fetched}" if view.fetched)].reject { it.to_s.empty? }.join(' · ')
-               end
-        [segment(" #{text}", view.error ? :error : :heading, width:)]
+        return [segment(" #{view.error}", :error, width:)] if view.error
+        return [segment(' No response yet. X runs the request.', :heading, width:)] if view.response.empty?
+
+        details = ['Response', view.language, ("fetched #{view.fetched}" if view.fetched)].reject { it.to_s.empty? }
+        [segment(" #{details.join(' · ')}", :heading, width:)]
       end
     end
   end

data/lib/raindown/tui/renderers/outline_renderer.rb

@@ -7,14 +7,14 @@ module Raindown
     # The open file's outline, right of the files: a row on each line, with its buttons.
     class OutlineRenderer < ListRenderer
       BUTTONS = [['Tab', 'Pane', :tab], ['Enter', 'Open', :enter], ['x', 'Run', :execute], ['e', 'Edit', :edit],
-                 ['w', 'Write back', :write_back], ['r', 'Reload', :reload], ['q', 'Quit', :quit]].freeze
+                 ['w', 'Write back', :write_back], ['r', 'Reload', :reload], ['/', 'Search', :search], ['q', 'Quit', :quit]].freeze
 
       def buttons = BUTTONS
 
       def page
-        if navigator.path then navigator.relative(navigator.path)
-        else 'No Markdown files'
-        end
+        return 'No Markdown files' unless navigator.path
+
+        navigator.relative(navigator.path)
       end
     end
   end

data/lib/raindown/tui/renderers/renderer.rb

@@ -10,6 +10,9 @@ module Raindown
     Renderer = Struct.new(:navigator, :pane, :width, :height) do
       include Rows
       include Text
+
+      # Its side of the line above the panes, which is blank unless it has something to say there, like a progress.
+      def spacer = [segment('', :blank)]
     end
   end
 end