marvi 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e3091d68f7f5ccd8b131401fd1dce1b010e7d8108125430de3c47bd68b403d4
-  data.tar.gz: f52d7849ff7982cb1b988b0e5e5e1c9a496661c56e689bd008fe34347b84dd7f
+  metadata.gz: 6f6a2c8745ddc2086bb12cb705f8564f1a23b770bb8b1026bdf89e2ccfea8bea
+  data.tar.gz: 879c6bbf77fac95dc588c8abce142144e2b27a5216d9831fd7c8d231956d248d
 SHA512:
-  metadata.gz: 54848bb6e78b5833c96eb6aaea4de9869c5dcd18c381c9b05dc69e1d2d9528f93be9846068bf89acc56f569c54b37e96bbd7868c070802b0ae644f98fa8914ed
-  data.tar.gz: d645f16e52d118bf57ef02dc5009cede7e7400377e7c6640030c78a36392ff37adab60a2bfbe8f88e749107bed3f57b153ab8f50754fc22ba822ff948adcbfcf
+  metadata.gz: d4edaa52fd6b82ad2443c821dab35e40ceb87cd28def6fa6401f413fb654f175d9fdf64b2ac070004c6dfdac99a1c757b0f4b6648388a4cbf952ab744d3815b2
+  data.tar.gz: b53ac675a9618f8e2be301758c3cb768315942665dc22dd81273bd35d8b490206d575b07689308c522f796f24987a6bd970a85c51cf9463dd8ee8d4e372077f8

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [0.8.0] - 2026-07-06
+
+- Turn the `o` prompt into a file picker. It lists Markdown/text documents under the current directory and narrows the list as you type (all space-separated terms must match, case-insensitive); select with `C-n`/`C-p` or the arrow keys and open with `Enter`. Input starting with `/`, `~`, `./`, or `../` switches to explicit path entry with shell-style `Tab` completion, and selecting a directory descends into it.
+- Open multiple files in tabs. Pass several files on the command line (`marvi a.md b.md`), and a tab bar with the file names appears at the top of the screen, wrapping to multiple rows when the terminal is narrow. Switch tabs with `Tab`/`Shift-Tab`, jump directly with `1`–`9`, or click a tab with the mouse. Press `o` to open another file in a new tab and `x` to close the current one. File-change polling covers every tab and marks updated ones with `●` in the bar.
+
+## [0.7.0] - 2026-06-15
+
+- Add incremental search to the curses pager. Press `/` to search as you type, with all matches highlighted (current match in bold) and the view jumping to the nearest match. Navigate matches with `n`/`N` (vi/less style); search is case-insensitive.
+
 ## [0.6.0] - 2026-06-11
 
 - Render Mermaid fenced code blocks as Unicode box-drawing art. Supports `flowchart`/`graph` (TD/TB/LR/RL), `sequenceDiagram`, `classDiagram`, and `stateDiagram`/`stateDiagram-v2`. Unsupported diagram types, malformed syntax, and over-width output fall back to the highlighted code block.

data/README.md

@@ -24,6 +24,24 @@ Render a Markdown file:
 marvi README.md
 ```
 
+Open multiple files at once — each file gets its own tab in a bar at the top of the screen (the bar wraps to multiple rows when tabs don't fit the terminal width):
+
+```bash
+marvi README.md CHANGELOG.md docs/guide.md
+```
+
+Tab keys inside the pager:
+
+| Key | Action |
+| --- | --- |
+| `Tab` / `Shift-Tab` | next / previous tab |
+| `1`–`9` | jump to tab by number |
+| mouse click on a tab | switch to that tab |
+| `o` | open a file in a new tab via the file picker |
+| `x` | close the current tab (closing the last one quits) |
+
+The `o` picker lists Markdown/text documents under the current directory and narrows the list as you type (every space-separated term must match, case-insensitive). Move the selection with `C-n`/`C-p` (or the arrow keys) and press `Enter` to open. Start the input with `/`, `~`, `./`, or `../` to enter an explicit path instead — `Tab` then completes it shell-style, and selecting a directory descends into it.
+
 Read from stdin:
 
 ```bash

data/exe/marvi

@@ -5,7 +5,7 @@ require "optparse"
 require_relative "../lib/marvi"
 
 OptionParser.new do |opts|
-  opts.banner = "Usage: marvi [FILE]\n       cat FILE | marvi"
+  opts.banner = "Usage: marvi [FILE...]\n       cat FILE | marvi"
   opts.on("-h", "--help", "Show help") do
     puts opts
     exit
@@ -16,14 +16,27 @@ OptionParser.new do |opts|
   end
 end.parse!
 
-markdown = if ARGV.empty?
-  $stdin.read
-else
-  File.read(ARGV[0])
+ARGV.each do |file|
+  abort "marvi: cannot open #{file}" unless File.file?(file) && File.readable?(file)
 end
 
 if $stdout.tty?
-  Marvi::Renderer::Curses.new.render(markdown, file: ARGV[0])
+  if ARGV.empty?
+    Marvi::Renderer::Curses.new.render($stdin.read)
+  else
+    Marvi::Renderer::Curses.new.render_files(ARGV)
+  end
 else
-  print Marvi::Renderer::ANSI.new.render(markdown)
+  renderer = Marvi::Renderer::ANSI.new
+  if ARGV.empty?
+    print renderer.render($stdin.read)
+  else
+    ARGV.each_with_index do |file, i|
+      if ARGV.size > 1
+        puts if i.positive?
+        puts "==> #{file} <=="
+      end
+      print renderer.render(File.read(file, encoding: Encoding::UTF_8))
+    end
+  end
 end

data/lib/marvi/renderer/curses/file_picker.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Marvi
+  module Renderer
+    class Curses
+      # Candidate discovery, filtering, and tab-completion behind the `o`
+      # (open file) picker. Pure filesystem/string logic with no curses calls,
+      # so it can be tested headlessly.
+      #
+      # Two modes, decided per keystroke from the typed input:
+      # - list mode: filter documents scanned under the base directory; every
+      #   whitespace-separated term must match somewhere in the path.
+      # - path mode (input starts with /, ~, ./ or ../): complete the typed
+      #   path against the filesystem, shell-style.
+      class FilePicker
+        SCAN_GLOB = "**/*.{md,markdown,mdown,mkd,txt}"
+        MAX_FILES = 2000
+
+        def initialize(base_dir = Dir.pwd)
+          @base_dir = base_dir
+        end
+
+        # Documents under the base directory, capped to keep the picker snappy
+        # in huge trees. Dir.glob skips hidden directories by default.
+        def all_files
+          @all_files ||= Dir.glob(SCAN_GLOB, base: @base_dir)
+            .reject { |path| File.directory?(File.join(@base_dir, path)) }
+            .sort
+            .first(MAX_FILES)
+        end
+
+        def path_mode?(input)
+          input.start_with?("/", "~", "./", "../")
+        end
+
+        def candidates(input)
+          path_mode?(input) ? path_candidates(input) : filter(input)
+        end
+
+        def filter(input)
+          terms = input.downcase.split
+          return all_files if terms.empty?
+
+          all_files.select do |path|
+            haystack = path.downcase
+            terms.all? { |term| haystack.include?(term) }
+          end
+        end
+
+        # Longest unambiguous extension of the typed path. A lone directory
+        # match gains a trailing slash so the next Tab descends into it.
+        def complete(input)
+          cands = path_candidates(input)
+          return input if cands.empty?
+
+          prefix = common_prefix(cands)
+          (prefix.length > input.length) ? prefix : input
+        end
+
+        private
+
+        # Filesystem entries matching the typed fragment. Directories get a
+        # trailing slash; a leading ~ in the input is preserved in the results.
+        def path_candidates(input)
+          home = Dir.home
+          home_style = input.start_with?("~/") || input == "~"
+          raw = home_style ? input.sub(/\A~/, home) : input
+          Dir.glob("#{glob_escape(raw)}*").sort.map do |path|
+            path = "#{path}/" if File.directory?(path)
+            home_style ? path.sub(home, "~") : path
+          end
+        end
+
+        def glob_escape(path)
+          path.gsub(/[\[\]{}*?\\]/) { |ch| "\\#{ch}" }
+        end
+
+        def common_prefix(strings)
+          strings.reduce do |prefix, s|
+            i = 0
+            i += 1 while i < prefix.length && i < s.length && prefix[i] == s[i]
+            prefix[0, i]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/marvi/renderer/curses/tab.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Marvi
+  module Renderer
+    class Curses
+      # Per-document state for one open file: source markdown, walked lines,
+      # scroll position, search state, and file-watch bookkeeping. All layout
+      # inputs (content width, page size) are passed in by the renderer so this
+      # class stays free of curses calls and can be tested headlessly.
+      class Tab
+        attr_reader :file, :lines, :markdown, :search_query, :matches, :current_match
+        attr_accessor :scroll
+
+        def initialize(file: nil, markdown: nil)
+          @file = file
+          @markdown = markdown || read_file
+          @scroll = 0
+          @lines = []
+          @walked_width = nil
+          clear_search
+          mark_reloaded
+        end
+
+        def label
+          @file ? File.basename(@file) : "(stdin)"
+        end
+
+        # Walk lazily: tabs that are not visible keep their lines from the last
+        # width they were displayed at and re-walk only when shown again.
+        def ensure_walked(width, page_size)
+          return if @walked_width == width
+
+          @walked_width = width
+          @lines = ASTWalker.new.walk(@markdown, max_width: width)
+          clamp_scroll(page_size)
+          refresh_search_after_rewalk(page_size)
+        end
+
+        def rewalk(width, page_size)
+          @walked_width = nil
+          ensure_walked(width, page_size)
+        end
+
+        def reload(width, page_size)
+          @markdown = read_file
+          rewalk(width, page_size)
+          mark_reloaded
+        end
+
+        def max_scroll(page_size)
+          [@lines.size - page_size, 0].max
+        end
+
+        def clamp_scroll(page_size)
+          @scroll = @scroll.clamp(0, max_scroll(page_size))
+        end
+
+        def scroll_by(delta, page_size)
+          @scroll = (@scroll + delta).clamp(0, max_scroll(page_size))
+        end
+
+        def visible_lines(page_size)
+          @lines[@scroll, page_size] || []
+        end
+
+        def current_source_line(page_size)
+          visible_lines(page_size).each { |line| return line.source_line if line.source_line }
+          # fall back to searching upward from scroll position
+          @scroll.downto(0) { |i| return @lines[i].source_line if @lines[i]&.source_line }
+          1
+        end
+
+        # --- file watching ---
+
+        # Returns true when the file changed on disk since the last check and
+        # the updated flag was newly raised.
+        def check_file_updated
+          return false unless @file
+
+          mtime = current_mtime
+          return false if mtime.nil? || mtime == @last_mtime
+
+          @last_mtime = mtime
+          return false if @file_updated
+
+          @file_updated = true
+          true
+        end
+
+        def file_updated?
+          @file_updated
+        end
+
+        def mark_reloaded
+          @last_mtime = current_mtime
+          @file_updated = false
+        end
+
+        # --- search ---
+
+        def update_search(query, page_size)
+          @search_query = query
+          recompute_matches
+          focus_match_from(@scroll, page_size) unless @matches.empty?
+        end
+
+        def commit_search
+          clear_search if @search_query.to_s.empty? || @matches.empty?
+        end
+
+        def clear_search
+          @search_query = nil
+          @matches = []
+          @current_match = nil
+        end
+
+        def jump_match(direction, page_size)
+          return if @matches.empty?
+
+          if @current_match.nil?
+            focus_match_from(@scroll, page_size)
+          else
+            set_current_match(@current_match + direction, page_size)
+          end
+        end
+
+        def highlight_ranges_for(line_index)
+          return nil if @matches.empty?
+
+          ranges = []
+          @matches.each_with_index do |(li, start, finish), i|
+            ranges << [start, finish, i == @current_match] if li == line_index
+          end
+          ranges.empty? ? nil : ranges
+        end
+
+        def search_hint
+          return "  n/N next/prev" if @search_query.nil? || @search_query.empty?
+          return "  no matches: #{@search_query}" if @matches.empty?
+
+          position = @current_match ? @current_match + 1 : 0
+          "  [#{position}/#{@matches.size}] n/N"
+        end
+
+        private
+
+        def read_file
+          # Force UTF-8 so markdown parses even under a C/POSIX locale where
+          # Encoding.default_external would be US-ASCII.
+          @file ? File.read(@file, encoding: Encoding::UTF_8) : ""
+        end
+
+        def current_mtime
+          return nil unless @file
+
+          File.mtime(@file)
+        rescue SystemCallError
+          nil
+        end
+
+        def refresh_search_after_rewalk(page_size)
+          return unless @search_query
+
+          recompute_matches
+          focus_match_from(@scroll, page_size) unless @matches.empty?
+        end
+
+        def recompute_matches
+          @matches = []
+          @current_match = nil
+          needle = @search_query.to_s.downcase
+          return if needle.empty?
+
+          @lines.each_with_index do |line, line_index|
+            haystack = line.plain_text.downcase
+            next if haystack.empty?
+
+            pos = 0
+            while (idx = haystack.index(needle, pos))
+              @matches << [line_index, idx, idx + needle.length]
+              pos = idx + needle.length
+            end
+          end
+        end
+
+        def focus_match_from(from_line, page_size)
+          return if @matches.empty?
+
+          index = @matches.index { |match| match[0] >= from_line } || 0
+          set_current_match(index, page_size)
+        end
+
+        def set_current_match(index, page_size)
+          return if @matches.empty?
+
+          @current_match = index % @matches.size
+          ensure_match_visible(@matches[@current_match][0], page_size)
+        end
+
+        def ensure_match_visible(line_index, page_size)
+          if line_index < @scroll || line_index >= @scroll + page_size
+            @scroll = [line_index, max_scroll(page_size)].min
+          end
+        end
+      end
+    end
+  end
+end

data/lib/marvi/renderer/curses/tab_bar.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "unicode/display_width"
+
+module Marvi
+  module Renderer
+    class Curses
+      # Pure layout computation for the tab bar so it can be tested without a
+      # terminal. Tabs are packed greedily left to right and wrap to a new row
+      # when the screen width is exceeded, producing a multi-row bar.
+      module TabBar
+        Item = Struct.new(:index, :text, :row, :col, :width, keyword_init: true) do
+          def contains?(y, x)
+            y == row && x >= col && x < col + width
+          end
+        end
+
+        module_function
+
+        def layout(labels, screen_width)
+          screen_width = [screen_width, 1].max
+          row = 0
+          col = 0
+          labels.each_with_index.map do |label, index|
+            text = truncate_to_width(" #{label} ", screen_width)
+            width = Unicode::DisplayWidth.of(text)
+            if col.positive? && col + width > screen_width
+              row += 1
+              col = 0
+            end
+            item = Item.new(index: index, text: text, row: row, col: col, width: width)
+            col += width
+            item
+          end
+        end
+
+        def rows(items)
+          items.empty? ? 0 : items.last.row + 1
+        end
+
+        def item_at(items, y, x)
+          items.find { |item| item.contains?(y, x) }
+        end
+
+        def truncate_to_width(text, max_width)
+          return text if Unicode::DisplayWidth.of(text) <= max_width
+
+          result = +""
+          width = 0
+          text.each_char do |ch|
+            ch_width = Unicode::DisplayWidth.of(ch)
+            break if width + ch_width > max_width
+
+            result << ch
+            width += ch_width
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/marvi/renderer/curses.rb

@@ -24,26 +24,39 @@ module Marvi
       FILE_POLL_INTERVAL_MS = 500
 
       CTRL_D = 4
+      CTRL_N = 14
+      CTRL_P = 16
       CTRL_U = 21
+      TAB_KEY = 9
 
       MIN_HORIZONTAL_PADDING = 2
       HORIZONTAL_PADDING_DIVISOR = 12
 
       def render(markdown, file: nil)
-        @file = file
-        @markdown = markdown
-        @scroll = 0
-        mark_reloaded
+        run([Tab.new(file: file, markdown: markdown)])
+      end
+
+      def render_files(files)
+        run(files.map { |file| Tab.new(file: file) })
+      end
+
+      private
+
+      def run(tabs)
+        @tabs = tabs
+        @current = 0
+        @search_input = nil
+        @status_message = nil
 
         init_curses_state
-        rewalk
+        current_tab.ensure_walked(content_width, page_size)
         draw
 
         catch(:quit) do
           loop do
             key = ::Curses.getch
             if key.nil? || key == -1
-              check_file_updated
+              poll_files
             else
               handle_key(key)
             end
@@ -53,7 +66,9 @@ module Marvi
         ::Curses.close_screen
       end
 
-      private
+      def current_tab
+        @tabs[@current]
+      end
 
       # ncurses uses the terminfo `rep` capability ("ESC[Nb") to compress runs of
       # identical glyphs, but ghostty mishandles it and drops the run from the
@@ -111,6 +126,7 @@ module Marvi
       end
 
       def handle_key(key)
+        @status_message = nil
         case key
         when "q", "Q", 27 then throw :quit
         when "j", ::Curses::Key::DOWN then scroll_by(1)
@@ -119,24 +135,119 @@ module Marvi
         when "u", CTRL_U then scroll_by(-page_size / 2)
         when "f", " ", ::Curses::Key::NPAGE then scroll_by(page_size)
         when "b", ::Curses::Key::PPAGE then scroll_by(-page_size)
-        when "g" then @scroll = 0
+        when "g" then current_tab.scroll = 0
                       draw
-        when "G" then @scroll = max_scroll
+        when "G" then current_tab.scroll = current_tab.max_scroll(page_size)
                       draw
-        when "e" then launch_editor if @file
-        when "r", "R" then reload_from_key if @file
+        when "/" then start_search
+        when "n" then jump_match(1)
+        when "N" then jump_match(-1)
+        when "e" then launch_editor if current_tab.file
+        when "r", "R" then reload_from_key if current_tab.file
+        when "\t", TAB_KEY then cycle_tab(1)
+        when ::Curses::Key::BTAB then cycle_tab(-1)
+        when "1".."9" then switch_to(key.to_i - 1)
+        when "o" then start_open
+        when "x" then close_current_tab
+        when ::Curses::Key::MOUSE then handle_mouse
         when ::Curses::Key::RESIZE then handle_resize
         end
       end
 
-      def handle_resize
-        rewalk
-        @scroll = [@scroll, max_scroll].min
+      # --- tabs ---
+
+      def cycle_tab(delta)
+        return if @tabs.size <= 1
+
+        switch_to((@current + delta) % @tabs.size)
+      end
+
+      def switch_to(index)
+        return if index.negative? || index >= @tabs.size
+
+        @current = index
+        current_tab.ensure_walked(content_width, page_size)
         draw
       end
 
-      def rewalk
-        @lines = ASTWalker.new.walk(@markdown, max_width: content_width)
+      def close_current_tab
+        throw :quit if @tabs.size == 1
+
+        @tabs.delete_at(@current)
+        @current = [@current, @tabs.size - 1].min
+        update_mousemask
+        # The bar may have lost a row (or disappeared), changing the page size.
+        current_tab.ensure_walked(content_width, page_size)
+        draw
+      end
+
+      def open_tab(path)
+        path = File.expand_path(path)
+        existing = @tabs.index { |tab| tab.file == path }
+        return switch_to(existing) if existing
+
+        unless File.file?(path) && File.readable?(path)
+          @status_message = " cannot open: #{path} "
+          draw
+          return
+        end
+
+        @tabs << Tab.new(file: path)
+        update_mousemask
+        switch_to(@tabs.size - 1)
+      end
+
+      def update_mousemask
+        return unless ::Curses.respond_to?(:mousemask)
+
+        # Claim the mouse only when the tab bar is shown, so single-document
+        # sessions keep native terminal text selection.
+        mask = (@tabs.size > 1) ? (::Curses::BUTTON1_CLICKED | ::Curses::BUTTON1_PRESSED) : 0
+        ::Curses.mousemask(mask)
+      end
+
+      def handle_mouse
+        event = ::Curses.getmouse
+        return unless event
+        return if (event.bstate & (::Curses::BUTTON1_CLICKED | ::Curses::BUTTON1_PRESSED)).zero?
+
+        item = TabBar.item_at(tab_layout, event.y, event.x)
+        switch_to(item.index) if item
+      end
+
+      def tab_layout
+        return [] if @tabs.size <= 1
+
+        labels = @tabs.each_with_index.map { |tab, i| tab_label(tab, i) }
+        TabBar.layout(labels, ::Curses.cols)
+      end
+
+      def tab_label(tab, index)
+        updated_mark = tab.file_updated? ? " ●" : ""
+        "#{index + 1}:#{tab.label}#{updated_mark}"
+      end
+
+      def tab_bar_height
+        TabBar.rows(tab_layout)
+      end
+
+      def draw_tab_bar(layout)
+        layout.each do |item|
+          ::Curses.setpos(item.row, item.col)
+          attr = if item.index == @current
+            ::Curses::A_REVERSE | ::Curses::A_BOLD
+          else
+            ::Curses.color_pair(COLOR_PAIRS[:cyan])
+          end
+          ::Curses.attron(attr) { ::Curses.addstr(item.text) }
+        rescue ::Curses::Error
+          # ignore write errors at screen edge
+        end
+      end
+
+      def handle_resize
+        current_tab.rewalk(content_width, page_size)
+        draw
       end
 
       def horizontal_padding
@@ -150,55 +261,28 @@ module Marvi
       end
 
       def reload_from_key
-        reload
-        mark_reloaded
+        current_tab.reload(content_width, page_size)
         draw
       end
 
-      def check_file_updated
-        return unless @file
-        mtime = current_mtime
-        return if mtime.nil? || mtime == @last_mtime
-
-        @last_mtime = mtime
-        return if @file_updated
-
-        @file_updated = true
-        draw_status_bar
-        ::Curses.refresh
-      end
-
-      def mark_reloaded
-        @last_mtime = current_mtime
-        @file_updated = false
-      end
-
-      def current_mtime
-        return nil unless @file
-        File.mtime(@file)
-      rescue SystemCallError
-        nil
+      def poll_files
+        updated = @tabs.select(&:check_file_updated)
+        draw unless updated.empty?
       end
 
       def launch_editor
+        tab = current_tab
         editor = ENV["EDITOR"] || ENV["VISUAL"] || "vi"
-        line = current_source_line
-        cmd = build_editor_command(editor, @file, line)
+        line = tab.current_source_line(page_size)
+        cmd = build_editor_command(editor, tab.file, line)
 
         ::Curses.close_screen
         system(cmd)
         init_curses_state
-        reload
-        mark_reloaded
+        tab.reload(content_width, page_size)
         draw
       end
 
-      def reload
-        @markdown = File.read(@file)
-        rewalk
-        @scroll = [@scroll, max_scroll].min
-      end
-
       def init_curses_state
         with_safe_term { ::Curses.init_screen }
         ::Curses.start_color
@@ -208,6 +292,7 @@ module Marvi
         ::Curses.stdscr.keypad(true)
         ::Curses.stdscr.timeout = FILE_POLL_INTERVAL_MS
         setup_colors
+        update_mousemask
       end
 
       def build_editor_command(editor, file, line)
@@ -224,58 +309,100 @@ module Marvi
         end
       end
 
-      def current_source_line
-        visible_lines.each { |line| return line.source_line if line.source_line }
-        # fall back to searching upward from scroll position
-        @scroll.downto(0) { |i| return @lines[i].source_line if @lines[i]&.source_line }
-        1
-      end
-
       def draw
         ::Curses.clear
+        layout = tab_layout
+        draw_tab_bar(layout)
+        offset = TabBar.rows(layout)
+        tab = current_tab
+        tab.clamp_scroll(page_size)
         padding = horizontal_padding
-        visible_lines.each_with_index do |line, row|
-          ::Curses.setpos(row, padding)
-          render_line(line)
+        tab.visible_lines(page_size).each_with_index do |line, row|
+          ::Curses.setpos(row + offset, padding)
+          render_line(line, tab.highlight_ranges_for(tab.scroll + row))
         end
         draw_status_bar
         ::Curses.refresh
       end
 
       def draw_status_bar
+        tab = current_tab
         ::Curses.setpos(::Curses.lines - 1, 0)
-        top = @scroll + 1
-        bottom = [@scroll + page_size, @lines.size].min
-        edit_hint = @file ? "  e edit" : ""
-        status = " #{top}-#{bottom}/#{@lines.size}  j/k scroll  g/G top/bottom#{edit_hint}  q quit"
-        updated_hint = @file_updated ? "  ● updated (r to reload) " : ""
-        available = [::Curses.cols - updated_hint.length, 0].max
+        top = tab.scroll + 1
+        bottom = [tab.scroll + page_size, tab.lines.size].min
+        tab_hint = (@tabs.size > 1) ? " [#{@current + 1}/#{@tabs.size}] Tab next" : ""
+        edit_hint = tab.file ? "  e edit" : ""
+        status = "#{tab_hint} #{top}-#{bottom}/#{tab.lines.size}  j/k scroll  g/G top/bottom  / search#{tab.search_hint}#{edit_hint}  o open  q quit"
+        right_hint = @status_message || (tab.file_updated? ? "  ● updated (r to reload) " : "")
+        available = [::Curses.cols - right_hint.length, 0].max
 
         ::Curses.attron(::Curses.color_pair(COLOR_PAIRS[:cyan])) do
           ::Curses.addstr(status.ljust(available)[0, available])
         end
-        unless updated_hint.empty?
+        unless right_hint.empty?
           ::Curses.attron(::Curses.color_pair(COLOR_PAIRS[:yellow]) | ::Curses::A_BOLD) do
-            ::Curses.addstr(updated_hint)
+            ::Curses.addstr(right_hint)
           end
         end
       end
 
-      def render_line(line)
+      def render_line(line, highlights = nil)
+        col = 0
         line.spans.each do |span|
-          render_span(span)
+          render_span(span, col, highlights)
+          col += span.text.length
         rescue ::Curses::Error
           # ignore write errors at line edge
         end
       end
 
-      def render_span(span)
+      def render_span(span, col_offset = 0, highlights = nil)
         attr = build_attr(span)
+        if highlights.nil? || highlights.empty?
+          write_text(span.text, attr)
+          return
+        end
+
+        highlight_segments(span.text, col_offset, highlights).each do |text, state|
+          seg_attr = attr
+          seg_attr |= ::Curses::A_REVERSE if state
+          seg_attr |= ::Curses::A_BOLD if state == :current
+          write_text(text, seg_attr)
+        end
+      end
+
+      def write_text(text, attr)
         if attr != 0
-          ::Curses.attron(attr) { ::Curses.addstr(span.text) }
+          ::Curses.attron(attr) { ::Curses.addstr(text) }
         else
-          ::Curses.addstr(span.text)
+          ::Curses.addstr(text)
+        end
+      end
+
+      # Split a span's text into runs of identical highlight state so each run can
+      # be drawn with the matching attributes. Highlight ranges are expressed in
+      # whole-line character offsets, hence col_offset locates this span on the line.
+      def highlight_segments(text, col_offset, highlights)
+        chars = text.chars
+        states = Array.new(chars.length)
+        highlights.each do |start, finish, current|
+          start.upto(finish - 1) do |c|
+            idx = c - col_offset
+            next if idx.negative? || idx >= chars.length
+            states[idx] = :current if current
+            states[idx] ||= true
+          end
+        end
+
+        segments = []
+        chars.each_with_index do |ch, i|
+          if segments.empty? || segments.last[1] != states[i]
+            segments << [ch.dup, states[i]]
+          else
+            segments.last[0] << ch
+          end
         end
+        segments
       end
 
       def build_attr(span)
@@ -293,22 +420,161 @@ module Marvi
         attr
       end
 
-      def visible_lines
-        @lines[@scroll, page_size] || []
+      def page_size
+        [::Curses.lines - 1 - tab_bar_height, 1].max
       end
 
-      def page_size
-        [::Curses.lines - 1, 1].max
+      def scroll_by(delta)
+        current_tab.scroll_by(delta, page_size)
+        draw
       end
 
-      def max_scroll
-        [@lines.size - page_size, 0].max
+      # --- line-editing prompts (search and open) ---
+
+      BACKSPACE_KEYS = [127, 8].freeze
+
+      def start_search
+        @search_input = ""
+        update_search(@search_input)
+        draw_prompt("/#{@search_input}")
+
+        loop do
+          key = ::Curses.getch
+          next if key.nil? || key == -1
+
+          case key
+          when 27 # ESC cancels and clears the search
+            current_tab.clear_search
+            @search_input = nil
+            draw
+            return
+          when "\n", "\r", 10, 13, ::Curses::Key::ENTER
+            current_tab.commit_search
+            @search_input = nil
+            draw
+            return
+          when *BACKSPACE_KEYS, ::Curses::Key::BACKSPACE
+            @search_input = @search_input[0...-1] || ""
+            update_search(@search_input)
+            draw_prompt("/#{@search_input}")
+          else
+            next unless key.is_a?(String) && key.match?(/\A[[:print:]]\z/)
+            @search_input += key
+            update_search(@search_input)
+            draw_prompt("/#{@search_input}")
+          end
+        end
       end
 
-      def scroll_by(delta)
-        @scroll = (@scroll + delta).clamp(0, max_scroll)
+      def update_search(query)
+        current_tab.update_search(query, page_size)
         draw
       end
+
+      def jump_match(direction)
+        current_tab.jump_match(direction, page_size)
+        draw
+      end
+
+      def start_open
+        picker = FilePicker.new
+        input = ""
+        selected = 0
+
+        loop do
+          candidates = picker.candidates(input)
+          selected = candidates.empty? ? 0 : selected % candidates.size
+          draw_picker(input, candidates, selected)
+
+          key = ::Curses.getch
+          next if key.nil? || key == -1
+
+          case key
+          when 27 # ESC cancels
+            draw
+            return
+          when "\n", "\r", 10, 13, ::Curses::Key::ENTER
+            choice = candidates[selected] || input.strip
+            if choice.empty?
+              draw
+              return
+            elsif choice.end_with?("/")
+              # descend into the selected directory and keep picking
+              input = choice
+              selected = 0
+            else
+              open_tab(choice)
+              return
+            end
+          when "\t", TAB_KEY
+            if picker.path_mode?(input)
+              input = picker.complete(input)
+            else
+              selected += 1
+            end
+          when ::Curses::Key::BTAB
+            selected -= 1
+          when CTRL_N, ::Curses::Key::DOWN
+            selected += 1
+          when CTRL_P, ::Curses::Key::UP
+            selected -= 1
+          when *BACKSPACE_KEYS, ::Curses::Key::BACKSPACE
+            input = input[0...-1] || ""
+            selected = 0
+          else
+            if key.is_a?(String) && key.match?(/\A[[:print:]]\z/)
+              input += key
+              selected = 0
+            end
+          end
+        end
+      end
+
+      def draw_picker(input, candidates, selected)
+        ::Curses.clear
+        width = ::Curses.cols
+        position = candidates.empty? ? 0 : selected + 1
+        header = " open file  (#{position}/#{candidates.size})  C-n/C-p select  Enter open  ESC cancel"
+        ::Curses.setpos(0, 0)
+        ::Curses.attron(::Curses.color_pair(COLOR_PAIRS[:cyan]) | ::Curses::A_BOLD) do
+          ::Curses.addstr(header.ljust(width)[0, width])
+        end
+
+        list_rows = [::Curses.lines - 2, 1].max
+        offset = (selected < list_rows) ? 0 : selected - list_rows + 1
+        (candidates[offset, list_rows] || []).each_with_index do |candidate, i|
+          ::Curses.setpos(1 + i, 0)
+          text = " #{candidate} ".ljust(width)[0, width]
+          if offset + i == selected
+            ::Curses.attron(::Curses::A_REVERSE) { ::Curses.addstr(text) }
+          else
+            ::Curses.addstr(text)
+          end
+        rescue ::Curses::Error
+          # ignore write errors at screen edge
+        end
+
+        prompt = "open: #{input}"
+        ::Curses.setpos(::Curses.lines - 1, 0)
+        ::Curses.attron(::Curses.color_pair(COLOR_PAIRS[:cyan])) do
+          ::Curses.addstr(prompt.ljust(width)[0, width])
+        end
+        ::Curses.setpos(::Curses.lines - 1, [prompt.length, width - 1].min)
+        ::Curses.refresh
+      end
+
+      def draw_prompt(prompt)
+        ::Curses.setpos(::Curses.lines - 1, 0)
+        ::Curses.attron(::Curses.color_pair(COLOR_PAIRS[:cyan])) do
+          ::Curses.addstr(prompt.ljust(::Curses.cols)[0, ::Curses.cols])
+        end
+        ::Curses.setpos(::Curses.lines - 1, [prompt.length, ::Curses.cols - 1].min)
+        ::Curses.refresh
+      end
     end
   end
 end
+
+require_relative "curses/tab"
+require_relative "curses/tab_bar"
+require_relative "curses/file_picker"

data/lib/marvi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Marvi
-  VERSION = "0.6.0"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marvi
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Mitsutaka Mimura
@@ -110,6 +110,9 @@ files:
 - lib/marvi/highlighter.rb
 - lib/marvi/renderer/ansi.rb
 - lib/marvi/renderer/curses.rb
+- lib/marvi/renderer/curses/file_picker.rb
+- lib/marvi/renderer/curses/tab.rb
+- lib/marvi/renderer/curses/tab_bar.rb
 - lib/marvi/version.rb
 - marvi-0.1.0.gem
 - sig/marvi.rbs