llv 0.1.0

data/lib/llv/tailer.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "listen"
+
+module Llv
+  # Follows a log file from EOF (or from start). Emits each new line to the
+  # supplied block on a background thread. Handles truncation/rotation by
+  # re-opening the file when its size shrinks or its inode changes.
+  class Tailer
+    def initialize(path, from_start: false)
+      @path = File.expand_path(path)
+      @from_start = from_start
+      @buffer = +""
+      @position = 0
+      @inode = nil
+      @stop = false
+    end
+
+    def each_line(&block)
+      @on_line = block
+      open_initial
+      emit_existing if @from_start
+      @position = File.size(@path)
+      @inode = File.stat(@path).ino
+
+      @listener = Listen.to(File.dirname(@path), only: Regexp.new("\\A#{Regexp.escape(File.basename(@path))}\\z")) do
+        check_for_changes
+      end
+      @listener.start
+
+      # Also poll occasionally as a fallback (some editors swap files in ways listen misses).
+      @poll = Thread.new do
+        until @stop
+          sleep 0.5
+          check_for_changes
+        end
+      end
+
+      self
+    end
+
+    def stop
+      @stop = true
+      @listener&.stop
+      @poll&.join(1)
+    end
+
+    private
+
+    def open_initial
+      raise ArgumentError, "log file not found: #{@path}" unless File.exist?(@path)
+    end
+
+    def emit_existing
+      File.open(@path, "rb") do |io|
+        io.each_line { |line| dispatch(line) }
+      end
+    end
+
+    def check_for_changes
+      return unless File.exist?(@path)
+
+      stat = File.stat(@path)
+      if @inode && stat.ino != @inode
+        @position = 0
+        @inode = stat.ino
+        @buffer = +""
+      elsif stat.size < @position
+        # truncation
+        @position = 0
+        @buffer = +""
+      end
+
+      return if stat.size == @position
+
+      File.open(@path, "rb") do |io|
+        io.seek(@position)
+        chunk = io.read(stat.size - @position)
+        @position = io.pos
+        next unless chunk
+
+        @buffer << chunk
+        while (idx = @buffer.index("\n"))
+          line = @buffer.slice!(0..idx)
+          dispatch(line)
+        end
+      end
+    end
+
+    def dispatch(line)
+      return if line.nil? || line.empty?
+
+      # File reads use binary mode so chunk boundaries don't split multibyte
+      # codepoints, but downstream code (regexes for `↳`, ANSI translation,
+      # JSON.generate) all need a valid UTF-8 string. Force the encoding and
+      # scrub anything invalid.
+      utf8 = line.dup.force_encoding(Encoding::UTF_8)
+      utf8.scrub!("?") unless utf8.valid_encoding?
+
+      @on_line.call(utf8)
+    rescue StandardError => e
+      warn "llv tailer: #{e.class}: #{e.message}"
+    end
+  end
+end

data/lib/llv/tui.rb

@@ -0,0 +1,521 @@
+# frozen_string_literal: true
+
+require "bubbletea"
+require "lipgloss"
+require "set"
+
+module Llv
+  module Tui
+    class GroupChangeMessage < Bubbletea::Message
+      attr_reader :event_type, :summary
+
+      def initialize(event_type:, summary:)
+        super()
+        @event_type = event_type
+        @summary = summary
+      end
+    end
+
+    class GroupBodyMessage < Bubbletea::Message
+      attr_reader :group
+
+      def initialize(group:)
+        super()
+        @group = group
+      end
+    end
+
+    # Bubbletea model: master/detail over Llv::GroupStore. Subscribes from a
+    # background thread that turns store events into messages on the runner.
+    class App
+      include Bubbletea::Model
+
+      KIND_GLYPHS = { http: "▶", job: "⚙", cable: "≋", untagged: "·" }.freeze
+      TOGGLEABLE_KINDS = %i[http job cable].freeze
+
+      # No padding here — each row already builds itself to the full
+      # list_width. Padding would shrink the content area and force lipgloss
+      # to wrap every row to two visual lines, which destroys the highlight.
+      ListStyle        = Lipgloss::Style.new
+      DetailStyle      = Lipgloss::Style.new.padding(0, 1)
+      HeaderStyle      = Lipgloss::Style.new.bold(true).foreground("#6cbcff")
+      SubheaderStyle   = Lipgloss::Style.new.foreground("#7b8190")
+      RowActiveStyle   = Lipgloss::Style.new.foreground("#ffffff").background("#1d4ed8").bold(true)
+      RowActiveMarker  = Lipgloss::Style.new.foreground("#6cbcff").bold(true)
+      RowStyle         = Lipgloss::Style.new
+      RowInactiveMarker = Lipgloss::Style.new.foreground("#262b3a")
+      MutedStyle       = Lipgloss::Style.new.foreground("#7b8190")
+      HelpStyle        = Lipgloss::Style.new.foreground("#7b8190").italic(true)
+      DividerStyle     = Lipgloss::Style.new.foreground("#262b3a")
+
+      VerbStyles = {
+        "GET"     => Lipgloss::Style.new.foreground("#6fcf97"),
+        "POST"    => Lipgloss::Style.new.foreground("#6cbcff"),
+        "PUT"     => Lipgloss::Style.new.foreground("#f2c14e"),
+        "PATCH"   => Lipgloss::Style.new.foreground("#f2c14e"),
+        "DELETE"  => Lipgloss::Style.new.foreground("#ef6c6c"),
+        "HEAD"    => Lipgloss::Style.new.foreground("#7b8190"),
+        "OPTIONS" => Lipgloss::Style.new.foreground("#7b8190")
+      }.freeze
+
+      StatusOkStyle    = Lipgloss::Style.new.foreground("#6fcf97").bold(true)
+      StatusRedirStyle = Lipgloss::Style.new.foreground("#56b6c2")
+      StatusWarnStyle  = Lipgloss::Style.new.foreground("#f2c14e")
+      StatusErrStyle   = Lipgloss::Style.new.foreground("#ef6c6c").bold(true)
+
+      def initialize(store:)
+        @store = store
+        @order = []
+        @summaries = {}
+        @details = {}
+        @selected = nil
+        @width = 100
+        @height = 30
+        @show_sql_source = true
+        @focus = :left
+        @detail_scroll = 0
+        @enabled_kinds = TOGGLEABLE_KINDS.to_set
+        seed_from_store
+      end
+
+      def width=(w); @width = w; end
+      def height=(h); @height = h; end
+
+      def init
+        [self, nil]
+      end
+
+      def update(message)
+        case message
+        when Bubbletea::WindowSizeMessage
+          @width = message.width
+          @height = message.height
+          [self, nil]
+        when Bubbletea::KeyMessage
+          handle_key(message)
+        when GroupChangeMessage
+          apply_change(message)
+          [self, nil]
+        when GroupBodyMessage
+          @details[message.group[:id]] = message.group
+          [self, nil]
+        else
+          [self, nil]
+        end
+      end
+
+      def view
+        list = render_list
+        detail = render_detail
+        body = Lipgloss.join_horizontal(Lipgloss::TOP, list, divider, detail)
+        [header, body, footer].join("\n")
+      end
+
+      private
+
+      def seed_from_store
+        @store.list(limit: 500).each do |summary|
+          @summaries[summary[:id]] = summary
+          @order << summary[:id]
+        end
+        @selected = @order.first
+        request_body(@selected) if @selected
+      end
+
+      def handle_key(msg)
+        name = msg.to_s
+
+        # Global keys (work regardless of focused pane).
+        case name
+        when "q", "ctrl+c"
+          return [self, Bubbletea.quit]
+        when "tab"
+          @focus = @focus == :left ? :right : :left
+          return [self, nil]
+        when "s"
+          @show_sql_source = !@show_sql_source
+          @detail_scroll = clamp_scroll(@detail_scroll)
+          return [self, nil]
+        when "H"
+          toggle_kind(:http)
+          return [self, nil]
+        when "J"
+          toggle_kind(:job)
+          return [self, nil]
+        when "C"
+          toggle_kind(:cable)
+          return [self, nil]
+        end
+
+        if @focus == :left
+          handle_left_key(name)
+        else
+          handle_right_key(name)
+        end
+        [self, nil]
+      end
+
+      def handle_left_key(name)
+        case name
+        when "up", "k"      then move_selection(-1)
+        when "down", "j"    then move_selection(1)
+        when "pgup"         then move_selection(-list_height_visible_rows)
+        when "pgdown", "pgdn" then move_selection(list_height_visible_rows)
+        when "g", "home"    then move_selection_to(0)
+        when "G", "end"     then move_selection_to(visible_order.length - 1)
+        when "right", "l", "enter"
+          @focus = :right
+        end
+      end
+
+      def handle_right_key(name)
+        case name
+        when "up", "k"        then scroll_detail(-1)
+        when "down", "j"      then scroll_detail(1)
+        when "pgup"           then scroll_detail(-(detail_body_rows - 1))
+        when "pgdown", "pgdn", "space" then scroll_detail(detail_body_rows - 1)
+        when "ctrl+u"         then scroll_detail(-(detail_body_rows / 2))
+        when "ctrl+d"         then scroll_detail(detail_body_rows / 2)
+        when "g", "home"      then @detail_scroll = 0
+        when "G", "end"       then @detail_scroll = max_detail_scroll
+        when "left", "h", "esc"
+          @focus = :left
+        end
+      end
+
+      def move_selection(delta)
+        order = visible_order
+        return if order.empty?
+
+        idx = order.index(@selected) || 0
+        move_selection_to((idx + delta).clamp(0, order.length - 1))
+      end
+
+      def move_selection_to(idx)
+        order = visible_order
+        return if order.empty?
+
+        new_selection = order[idx.clamp(0, order.length - 1)]
+        return if new_selection == @selected
+
+        @selected = new_selection
+        @detail_scroll = 0
+        request_body(@selected)
+      end
+
+      def scroll_detail(delta)
+        @detail_scroll = clamp_scroll(@detail_scroll + delta)
+      end
+
+      def clamp_scroll(value)
+        value.clamp(0, max_detail_scroll)
+      end
+
+      def max_detail_scroll
+        return 0 unless @selected
+
+        group = @details[@selected]
+        return 0 unless group
+
+        lines = visible_detail_lines(group)
+        [lines.length - detail_body_rows, 0].max
+      end
+
+      def visible_detail_lines(group)
+        (group[:lines] || []).reject { |l| l.type == :sql_source && !@show_sql_source }
+      end
+
+      def visible_order
+        @order.select do |id|
+          summary = @summaries[id]
+          next true unless summary
+          kind = summary[:kind]
+          next true if kind == :untagged
+          @enabled_kinds.include?(kind)
+        end
+      end
+
+      def toggle_kind(kind)
+        if @enabled_kinds.include?(kind)
+          @enabled_kinds.delete(kind)
+        else
+          @enabled_kinds.add(kind)
+        end
+        # If the current selection is now filtered out, move to the nearest
+        # visible item (or clear it).
+        order = visible_order
+        unless order.include?(@selected)
+          @selected = order.first
+          @detail_scroll = 0
+          request_body(@selected) if @selected
+        end
+      end
+
+      def apply_change(message)
+        summary = message.summary
+        case message.event_type
+        when :group_created
+          unless @summaries.key?(summary[:id])
+            @order.unshift(summary[:id])
+          end
+          @summaries[summary[:id]] = summary
+          @selected ||= summary[:id]
+        when :group_updated, :group_completed
+          @summaries[summary[:id]] = summary
+          # refresh body if user is currently viewing it
+          request_body(summary[:id]) if @selected == summary[:id]
+        when :group_evicted
+          @summaries.delete(summary[:id])
+          @details.delete(summary[:id])
+          @order.delete(summary[:id])
+          if @selected == summary[:id]
+            @selected = @order.first
+            request_body(@selected) if @selected
+          end
+        end
+      end
+
+      def request_body(id)
+        return unless id
+
+        full = @store.fetch(id)
+        @details[id] = full if full
+      end
+
+      def header
+        title = HeaderStyle.render("llv")
+        focus_hint = "[#{@focus == :left ? "LIST" : "DETAIL"}]"
+        keys = @focus == :left ? "↑/↓ select · → detail" : "↑/↓ scroll · ← back · PgUp/PgDn"
+        kinds = TOGGLEABLE_KINDS.map { |k| @enabled_kinds.include?(k) ? k.to_s : "·#{k}" }.join("/")
+        total = visible_order.length
+        status = SubheaderStyle.render(
+          "#{total}/#{@order.length} · #{focus_hint} · #{keys} · tab swap · H/J/C toggle #{kinds} · s ↳ · q quit"
+        )
+        line = "#{title}  #{status}"
+        Lipgloss.place_horizontal(@width, Lipgloss::LEFT, line)
+      end
+
+      def footer
+        HelpStyle.render(@selected ? @selected.to_s : "")
+      end
+
+      def divider
+        rows = body_height
+        glyph = @focus == :right ? "┃" : "│"
+        style = @focus == :right ? Lipgloss::Style.new.foreground("#6cbcff") : DividerStyle
+        Array.new(rows) { style.render(glyph) }.join("\n")
+      end
+
+      def body_height
+        [@height - 3, 5].max
+      end
+
+      def list_width
+        [(@width * 0.4).floor, 32].max.then { |w| [w, @width - 20].min }
+      end
+
+      def detail_width
+        @width - list_width - 1
+      end
+
+      def render_list
+        rows = list_height_visible_rows
+        ids = visible_window(rows)
+        lines = ids.map { |id| format_row(id) }
+        # Pad to fill height for stable layout. Use raw spaces — no styling
+        # so empty space below the last item doesn't get a highlight.
+        while lines.length < rows
+          lines << (" " * list_width)
+        end
+        lines.join("\n")
+      end
+
+      def list_height_visible_rows
+        [body_height - 1, 3].max
+      end
+
+      def visible_window(rows)
+        order = visible_order
+        return [] if order.empty?
+
+        idx = order.index(@selected) || 0
+        start = [idx - rows / 2, 0].max
+        finish = [start + rows, order.length].min
+        start = [finish - rows, 0].max
+        order[start...finish]
+      end
+
+      def format_row(id)
+        summary = @summaries[id]
+        return " " * list_width unless summary
+
+        active = (id == @selected)
+        glyph = KIND_GLYPHS[summary[:kind]] || "?"
+        status_text = format_status(summary)
+        duration_text = format_duration(summary[:duration_ms])
+        title_raw = (summary[:title] || id).to_s
+
+        meta_parts = [status_text, duration_text].reject(&:empty?)
+        meta_plain = meta_parts.empty? ? "" : " #{meta_parts.join(" ")}"
+
+        # The first column is a 1-char focus marker (full block on the active
+        # row, nothing on the rest). The remaining list_width - 1 chars are the
+        # row body, padded out to fill so the background highlight covers the
+        # entire line.
+        marker_glyph = active ? "▌" : " "
+        marker = active ? RowActiveMarker.render(marker_glyph) : RowInactiveMarker.render(marker_glyph)
+
+        body_width = list_width - 1
+        # The row body shape is " <glyph> <title><meta>": leading space, glyph,
+        # space, title (variable), meta segment. 3 fixed chars plus title plus
+        # meta's visible length must equal body_width.
+        title_room = body_width - 3 - meta_plain.length
+        title_room = [title_room, 4].max
+
+        title_text = title_raw.length > title_room ? "#{title_raw[0, title_room - 1]}…" : title_raw
+        title_padded = title_text.ljust(title_room)
+
+        if active
+          # Active row: single bg-highlight covers the whole line. Inline
+          # foreground colours would fight the highlight, so we keep it flat.
+          body = " #{glyph} #{title_padded}#{meta_plain}"
+          body = body[0, body_width].ljust(body_width)
+          "#{marker}#{RowActiveStyle.render(body)}"
+        else
+          title_styled = colourise_verb_in_title(title_padded)
+          meta_styled = colourise_meta(status_text, duration_text)
+
+          styled_body = " #{glyph} #{title_styled}#{meta_styled}"
+          visible_len = 3 + title_room + meta_plain.length
+          padding = " " * [body_width - visible_len, 0].max
+          "#{marker}#{styled_body}#{padding}"
+        end
+      end
+
+      def colourise_verb_in_title(title_padded)
+        m = title_padded.match(/\A([A-Z]+)(\s.*)\z/m)
+        return title_padded unless m
+
+        style = VerbStyles[m[1]]
+        return title_padded unless style
+
+        "#{style.render(m[1])}#{m[2]}"
+      end
+
+      def colourise_meta(status_text, duration_text)
+        return "" if status_text.empty? && duration_text.empty?
+
+        parts = []
+        parts << status_style_for(status_text).render(status_text) unless status_text.empty?
+        parts << MutedStyle.render(duration_text) unless duration_text.empty?
+        " #{parts.join(" ")}"
+      end
+
+      def status_style_for(text)
+        case text
+        when /\A2\d\d\z/ then StatusOkStyle
+        when /\A3\d\d\z/ then StatusRedirStyle
+        when /\A4\d\d\z/ then StatusWarnStyle
+        when /\A5\d\d\z/ then StatusErrStyle
+        when "ok"        then StatusOkStyle
+        when "stopped"   then StatusErrStyle
+        else MutedStyle
+        end
+      end
+
+      def format_status(summary)
+        s = summary[:status]
+        return "…" if s.nil?
+        s.to_s
+      end
+
+      def format_duration(ms)
+        return "" if ms.nil?
+        return "#{ms.round(1)}ms" if ms < 1000
+        "#{(ms / 1000.0).round(2)}s"
+      end
+
+      def render_detail
+        group = @selected ? @details[@selected] : nil
+        return DetailStyle.width(detail_width).render(MutedStyle.render("(no selection)")) unless group
+
+        lines = visible_detail_lines(group)
+        rows = detail_body_rows
+        @detail_scroll = clamp_scroll(@detail_scroll)
+
+        first = @detail_scroll
+        last = [@detail_scroll + rows, lines.length].min
+        scroll_info =
+          if lines.length > rows
+            visible_from = first + 1
+            visible_to = last
+            pct = max_detail_scroll.zero? ? 100 : ((first.to_f / max_detail_scroll) * 100).round
+            "  #{visible_from}-#{visible_to} of #{lines.length} (#{pct}%)"
+          else
+            ""
+          end
+
+        content_width = [detail_width - 2, 10].max
+        head_text = (group[:title] || group[:id]).to_s
+        head = HeaderStyle.render(Ansi.truncate(head_text, content_width))
+
+        sub_text = [
+          group[:kind],
+          "#{group[:line_count]} lines",
+          format_duration(group[:duration_ms]),
+          group[:status] || "in flight",
+          group[:id]
+        ].compact.join(" · ") + scroll_info
+        sub = SubheaderStyle.render(Ansi.truncate(sub_text, content_width))
+
+        visible = lines[first, rows] || []
+        # Detail content width: minus 2 for DetailStyle's left/right padding.
+        # We truncate each log line ANSI-aware so the rendered detail block
+        # has exactly one visual line per log entry; otherwise long SQL
+        # queries wrap and push everything else (including the list pane on
+        # the other side of join_horizontal) off the screen.
+        badge_width = 20
+        line_strs = visible.map do |line|
+          badge = MutedStyle.render("[#{line.type}]".ljust(badge_width))
+          body_room = content_width - badge_width - 1
+          body = body_room.positive? ? Ansi.truncate(line.raw, body_room) : ""
+          "#{badge} #{body}"
+        end
+
+        # Pad to a stable height so the layout doesn't jiggle as we scroll.
+        while line_strs.length < rows
+          line_strs << ""
+        end
+
+        out = [head, sub, "", *line_strs].join("\n")
+        DetailStyle.width(detail_width).render(out)
+      end
+
+      def detail_body_rows
+        # body_height minus head, sub, and the blank divider line.
+        [body_height - 3, 3].max
+      end
+    end
+
+    # Wraps Bubbletea::Runner + store subscription.
+    class Program
+      def initialize(store:)
+        @store = store
+        @model = App.new(store: store)
+        @runner = Bubbletea::Runner.new(@model, alt_screen: true)
+      end
+
+      def run
+        subscription = @store.subscribe do |type, group|
+          msg = GroupChangeMessage.new(event_type: type, summary: group.summary)
+          @runner.send(msg)
+        end
+        begin
+          @runner.run
+        ensure
+          @store.unsubscribe(subscription)
+        end
+      end
+    end
+  end
+end

data/lib/llv/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Llv
+  VERSION = "0.1.0"
+end