solid_queue_tui 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 362a8f6c4d4bd257ed5bdc4a7eaf93fb986b978313a5847bffd3dfe8e9f963ed
-  data.tar.gz: 9aabeac6f1fa7404ff7a485b2a47669ed1313244348fc29dc4bc34a751ab9bd8
+  metadata.gz: edcec2bda0cc128879fda2b066fcbd560c7879c4a2554d53d3ff01c50c4d5040
+  data.tar.gz: 2457d9eb670fddb7a851f64dbe37c1f2b69fdcd9608d69e2feb5b0af4b406358
 SHA512:
-  metadata.gz: 7de0862123508768172c46a17458c55651b6bda487d79e76f7e61933d223e29e848ba0614b4fc116acc8222dc5a245ac590fc92cff595b3c65c67367537589c1
-  data.tar.gz: b8d145ba61da8f1de1fe3a4c1b3678e06ca36e19e6e4622acc67942adf194228eb6c96e09cfa114168cc8c3b3b28140ffd2d53b05d653081394c89406fdf6648
+  metadata.gz: a6f0174997d605c9e0d83c22c8a53973b017cd2e4cdd9cc260ace6f249d1a029c0c475a78124d5fd9537b9e5d1ca361c4b64adbd4a47c5842d0d05ede3ae153d
+  data.tar.gz: af07fa966c63b5f63b4f2e8d034e0d44b023294d443403b9130a631a5ecd3c52913dc0d71ef42ae85de8d81d37fc9e3c5e8def0f983cff6e372526bdf8e710bd

data/exe/qtop

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Boot the host Rails application's environment.
+# This ensures ActiveRecord, Solid Queue models, and the database
+# connection pool are fully loaded before the TUI starts.
+env_file = File.join(Dir.pwd, "config", "environment.rb")
+
+unless File.exist?(env_file)
+  $stderr.puts "Error: config/environment.rb not found in #{Dir.pwd}"
+  $stderr.puts ""
+  $stderr.puts "qtop must be run from your Rails application's root directory."
+  $stderr.puts "Make sure solid_queue_tui is in your Gemfile and Solid Queue is configured."
+  exit 1
+end
+
+require env_file
+
+# Logs must never hit STDOUT/STDERR — that would corrupt the TUI.
+# If a log/ directory exists (traditional Rails), write there.
+# Otherwise (Rails 8 defaults), silence logging.
+#TODO: figure out logging for rails 8, docker
+
+log_dir = File.join(Dir.pwd, "log")
+if Dir.exist?(log_dir)
+  log_file = File.join(log_dir, "#{Rails.env}.log")
+  tui_logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(log_file))
+  tui_logger.push_tags("SQTUI")
+else
+  tui_logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(File::NULL))
+end
+ActiveRecord::Base.logger = tui_logger
+Rails.logger = tui_logger
+
+SolidQueueTui::CLI.run(ARGV)

data/exe/sqtui

@@ -19,7 +19,24 @@ require env_file
 # Log ActiveRecord queries to the Rails log file so TUI operations
 # are visible in log/development.log (or whichever environment is active).
 # Tag all TUI logs with [SQTUI] so they're easy to distinguish from app logs.
-ActiveRecord::Base.logger = Rails.logger
-Rails.logger.push_tags("SQTUI") if Rails.logger.respond_to?(:push_tags)
+# CORRUPTING TERMINAL
+# ActiveRecord::Base.logger = Rails.logger
+# Rails.logger.push_tags("SQTUI") if Rails.logger.respond_to?(:push_tags)
+
+# Logs must never hit STDOUT/STDERR — that would corrupt the TUI.
+# If a log/ directory exists (traditional Rails), write there.
+# Otherwise (Rails 8 defaults), silence logging.
+#TODO: figure out logging for rails 8, docker
+
+log_dir = File.join(Dir.pwd, "log")
+if Dir.exist?(log_dir)
+  log_file = File.join(log_dir, "#{Rails.env}.log")
+  tui_logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(log_file))
+  tui_logger.push_tags("SQTUI")
+else
+  tui_logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(File::NULL))
+end
+ActiveRecord::Base.logger = tui_logger
+Rails.logger = tui_logger
 
 SolidQueueTui::CLI.run(ARGV)

data/lib/solid_queue_tui/application.rb

@@ -143,10 +143,17 @@ module SolidQueueTui
         return false
       end
 
-      # If view is in a modal state (filter, confirm), it gets all input
+      # If view is in a modal state (filter, confirm, detail sub-view), it gets all input
       if current_view.respond_to?(:capturing_input?) && current_view.capturing_input?
         result = current_view.handle_input(event)
-        refresh_data! if result == :refresh
+        case result
+        when :refresh, :enter_queue, :exit_queue
+          refresh_data!
+        when :load_more
+          load_more_data!
+        when :open_detail
+          open_detail
+        end
         return false
       end
 
@@ -241,11 +248,21 @@ module SolidQueueTui
       return unless item
 
       case @current_view
+      when VIEW_QUEUES
+        if current_view.detail_mode?
+          @job_detail.show(job: item) if item.respond_to?(:id)
+        else
+          result = current_view.handle_input({ type: :key, code: "enter" })
+          refresh_data! if result == :enter_queue
+        end
       when VIEW_FAILED
         failed_job = Data::FailedQuery.fetch_one(item.id) if item.respond_to?(:id)
         @job_detail.show(failed_job: failed_job || item)
       when VIEW_IN_PROGRESS, VIEW_BLOCKED, VIEW_SCHEDULED, VIEW_FINISHED
         @job_detail.show(job: item) if item.respond_to?(:id)
+      when VIEW_WORKERS
+        running_jobs = Data::ProcessesQuery.fetch_running_jobs(process_id: item.id)
+        @job_detail.show(process: item, running_jobs: running_jobs)
       end
     end
 
@@ -262,8 +279,16 @@ module SolidQueueTui
         @stats = Data::Stats.fetch
         current_view.update(stats: @stats)
       when VIEW_QUEUES
-        queues = Data::QueuesQuery.fetch
-        current_view.update(queues: queues)
+        if current_view.detail_mode?
+          q = current_view.selected_queue_name
+          f = current_view.filters
+          current_view.total_count = Data::JobsQuery.count_pending(queue: q, filter: f[:class_name])
+          jobs = Data::JobsQuery.fetch_pending(queue: q, filter: f[:class_name], limit: SolidQueueTui.page_size, offset: 0)
+          current_view.update_detail(jobs: jobs)
+        else
+          queues = Data::QueuesQuery.fetch
+          current_view.update(queues: queues)
+        end
       when VIEW_FAILED
         f = current_view.filters
         current_view.total_count = Data::FailedQuery.count(filter: f[:class_name], queue: f[:queue])
@@ -305,6 +330,13 @@ module SolidQueueTui
       offset = view.current_offset
 
       case @current_view
+      when VIEW_QUEUES
+        if view.detail_mode?
+          q = view.selected_queue_name
+          f = view.filters
+          more = Data::JobsQuery.fetch_pending(queue: q, filter: f[:class_name], limit: SolidQueueTui.page_size, offset: offset)
+          view.append(jobs: more)
+        end
       when VIEW_FAILED
         f = view.filters
         more = Data::FailedQuery.fetch(filter: f[:class_name], queue: f[:queue], limit: SolidQueueTui.page_size, offset: offset)
@@ -460,6 +492,7 @@ module SolidQueueTui
         help_section("Actions"),
         help_line("r", "Refresh data"),
         help_line("/", "Filter by class name"),
+        help_line("c", "Clear active filter"),
         help_line("R", "Retry failed job (in Failed view)"),
         help_line("D", "Discard failed job (in Failed view)"),
         help_line("A", "Retry all failed jobs"),

data/lib/solid_queue_tui/cli.rb

@@ -15,7 +15,7 @@ module SolidQueueTui
       options = {}
 
       OptionParser.new do |opts|
-        opts.banner = "Usage: sqtui [options]"
+        opts.banner = "Usage: qtop [options]"
         opts.separator ""
         opts.separator "Options:"
 
@@ -36,7 +36,7 @@ module SolidQueueTui
         end
 
         opts.on("-v", "--version", "Show version") do
-          puts "sqtui v#{SolidQueueTui::VERSION}"
+          puts "qtop v#{SolidQueueTui::VERSION}"
           exit
         end
 

data/lib/solid_queue_tui/components/job_table.rb

@@ -3,6 +3,8 @@
 module SolidQueueTui
   module Components
     class JobTable
+      include FormattingHelpers
+
       STATUS_COLORS = {
         "ready" => :green,
         "claimed" => :yellow,
@@ -49,9 +51,6 @@ module SolidQueueTui
         text + " "
       end
 
-      def format_number(n)
-        n.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
-      end
 
       def render_table(frame, area, table_state)
         widths = @columns.map do |col|

data/lib/solid_queue_tui/data/hourly_stats_query.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Data
+    class HourlyStatsQuery
+      Result = Struct.new(:data, :total, :peak, :avg, keyword_init: true)
+
+      def self.enqueued_per_hour
+        raw = SolidQueue::Job
+          .where(created_at: 24.hours.ago..)
+          .group(hour_sql(:created_at))
+          .count
+        build_result(raw)
+      rescue => e
+        empty_result
+      end
+
+      def self.processed_per_hour
+        raw = SolidQueue::Job
+          .where.not(finished_at: nil)
+          .where(finished_at: 24.hours.ago..)
+          .group(hour_sql(:finished_at))
+          .count
+        build_result(raw)
+      rescue => e
+        empty_result
+      end
+
+      def self.failed_per_hour
+        raw = SolidQueue::FailedExecution
+          .where(created_at: 24.hours.ago..)
+          .group(hour_sql(:created_at))
+          .count
+        build_result(raw)
+      rescue => e
+        empty_result
+      end
+
+      def self.empty_result
+        now = Time.now.utc
+        data = (0..23).map { |i| (now - (23 - i) * 3600).strftime("%H").to_i }
+        Result.new(data: data.map { 0 }, total: 0, peak: 0, avg: 0)
+      end
+
+      class << self
+        private
+
+        def hour_sql(column)
+          if sqlite?
+            Arel.sql("strftime('%Y-%m-%d %H:00:00', #{column})")
+          else
+            Arel.sql("DATE_TRUNC('hour', #{column})")
+          end
+        end
+
+        def build_result(raw_hash)
+          now = Time.now.utc
+
+          lookup = {}
+          raw_hash.each do |key, count|
+            time = key.is_a?(String) ? Time.parse("#{key} UTC") : key
+            lookup[time.strftime("%Y-%m-%d %H")] = count
+          end
+
+          # 24-slot array, oldest to newest — values only (for sparkline)
+          data = (0..23).map do |i|
+            hour_time = now - (23 - i) * 3600
+            key = hour_time.strftime("%Y-%m-%d %H")
+            lookup[key] || 0
+          end
+
+          total = data.sum
+          peak = data.max || 0
+          avg = total / 24
+
+          Result.new(data: data, total: total, peak: peak, avg: avg)
+        end
+
+        def sqlite?
+          SolidQueue::Job.connection.adapter_name.downcase.include?("sqlite")
+        end
+      end
+    end
+  end
+end

data/lib/solid_queue_tui/data/jobs_query.rb

@@ -13,6 +13,7 @@ module SolidQueueTui
 
       def self.fetch(status:, filter: nil, queue: nil, limit: 100, offset: 0)
         case status
+        when "pending"   then fetch_pending(queue: queue, filter: filter, limit: limit, offset: offset)
         when "claimed"   then fetch_claimed(filter: filter, queue: queue, limit: limit, offset: offset)
         when "blocked"   then fetch_blocked(filter: filter, queue: queue, limit: limit, offset: offset)
         when "scheduled" then fetch_scheduled(filter: filter, queue: queue, limit: limit, offset: offset)
@@ -25,6 +26,7 @@ module SolidQueueTui
 
       def self.count(status:, filter: nil, queue: nil)
         case status
+        when "pending"   then count_pending(queue: queue, filter: filter)
         when "claimed"   then count_scope(SolidQueue::ClaimedExecution.joins(:job), filter: filter, queue: queue)
         when "blocked"   then count_scope(SolidQueue::BlockedExecution.joins(:job), filter: filter, queue: queue)
         when "scheduled" then count_scope(SolidQueue::ScheduledExecution.joins(:job), filter: filter, queue: queue)
@@ -35,6 +37,35 @@ module SolidQueueTui
         0
       end
 
+      def self.fetch_pending(queue:, filter: nil, limit: 100, offset: 0)
+        scope = SolidQueue::ReadyExecution.joins(:job)
+        scope = scope.where(queue_name: queue) if queue
+        scope = apply_class_name_filter(scope, filter)
+        scope = scope.order(priority: :asc, job_id: :asc).offset(offset).limit(limit)
+
+        scope.includes(:job).map do |re|
+          job = re.job
+          Job.new(
+            id: job.id,
+            queue_name: job.queue_name,
+            class_name: job.class_name,
+            priority: job.priority,
+            status: "pending",
+            active_job_id: job.active_job_id,
+            arguments: job.arguments,
+            scheduled_at: job.scheduled_at,
+            created_at: job.created_at
+          )
+        end
+      end
+
+      def self.count_pending(queue:, filter: nil)
+        scope = SolidQueue::ReadyExecution.joins(:job)
+        scope = scope.where(queue_name: queue) if queue
+        scope = apply_class_name_filter(scope, filter)
+        scope.count
+      end
+
       def self.fetch_claimed(filter: nil, queue: nil, limit: 100, offset: 0)
         scope = SolidQueue::ClaimedExecution.joins(:job)
         scope = scope.merge(SolidQueue::Job.where(queue_name: queue)) if queue

data/lib/solid_queue_tui/data/processes_query.rb

@@ -29,6 +29,29 @@ module SolidQueueTui
         end
       end
 
+      RunningJob = Struct.new(
+        :job_id, :class_name, :queue_name, :started_at,
+        keyword_init: true
+      )
+
+      def self.fetch_running_jobs(process_id:)
+        SolidQueue::ClaimedExecution
+          .where(process_id: process_id)
+          .joins(:job).includes(:job)
+          .order(:created_at)
+          .map do |ce|
+            job = ce.job
+            RunningJob.new(
+              job_id: job.id,
+              class_name: job.class_name,
+              queue_name: job.queue_name,
+              started_at: ce.created_at
+            )
+          end
+      rescue => e
+        []
+      end
+
       def self.fetch
         SolidQueue::Process.where(kind: "Worker").order(:id).map do |proc|
           Process.new(

data/lib/solid_queue_tui/data/stats.rb

@@ -5,7 +5,9 @@ module SolidQueueTui
     class Stats
       attr_reader :ready, :claimed, :failed, :scheduled, :blocked,
                   :total_jobs, :completed_jobs, :process_count,
-                  :processes_by_kind
+                  :processes_by_kind,
+                  :enqueued_per_hour, :processed_per_hour, :failed_per_hour,
+                  :queue_depths
 
       def initialize(data)
         @ready = data[:ready]
@@ -17,6 +19,10 @@ module SolidQueueTui
         @completed_jobs = data[:completed_jobs]
         @process_count = data[:process_count]
         @processes_by_kind = data[:processes_by_kind]
+        @enqueued_per_hour = data[:enqueued_per_hour]
+        @processed_per_hour = data[:processed_per_hour]
+        @failed_per_hour = data[:failed_per_hour]
+        @queue_depths = data[:queue_depths]
       end
 
       def self.fetch
@@ -29,7 +35,11 @@ module SolidQueueTui
           total_jobs: SolidQueue::Job.count,
           completed_jobs: SolidQueue::Job.finished.count,
           process_count: SolidQueue::Process.count,
-          processes_by_kind: SolidQueue::Process.group(:kind).count
+          processes_by_kind: SolidQueue::Process.group(:kind).count,
+          enqueued_per_hour: HourlyStatsQuery.enqueued_per_hour,
+          processed_per_hour: HourlyStatsQuery.processed_per_hour,
+          failed_per_hour: HourlyStatsQuery.failed_per_hour,
+          queue_depths: SolidQueue::ReadyExecution.group(:queue_name).count
         )
       rescue => e
         empty(error: e.message)
@@ -39,7 +49,9 @@ module SolidQueueTui
         new(
           ready: 0, claimed: 0, failed: 0, scheduled: 0, blocked: 0,
           total_jobs: 0, completed_jobs: 0, process_count: 0,
-          processes_by_kind: {}
+          processes_by_kind: {},
+          enqueued_per_hour: nil, processed_per_hour: nil, failed_per_hour: nil,
+          queue_depths: {}
         )
       end
     end

data/lib/solid_queue_tui/formatting_helpers.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module FormattingHelpers
+    def time_ago(time)
+      return "n/a" unless time
+      seconds = (Time.now.utc - time).to_i
+      case seconds
+      when 0..59       then "#{seconds}s ago"
+      when 60..3599    then "#{seconds / 60}m ago"
+      when 3600..86399 then "#{seconds / 3600}h ago"
+      else "#{seconds / 86400}d ago"
+      end
+    end
+
+    def format_time(time)
+      return "n/a" unless time
+      time.strftime("%Y-%m-%d %H:%M:%S")
+    end
+
+    def format_duration(seconds)
+      return "n/a" unless seconds
+      seconds = seconds.to_i
+      if seconds < 1
+        "<1s"
+      elsif seconds < 60
+        "#{seconds}s"
+      elsif seconds < 3600
+        "#{seconds / 60}m #{seconds % 60}s"
+      elsif seconds < 86400
+        "#{seconds / 3600}h #{(seconds % 3600) / 60}m"
+      else
+        "#{seconds / 86400}d #{(seconds % 86400) / 3600}h"
+      end
+    end
+
+    def format_number(n)
+      return "0" if n.nil? || n == 0
+      n.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+    end
+
+    def truncate(str, max)
+      return "" unless str
+      str.length > max ? "#{str[0...max - 3]}..." : str
+    end
+
+    def humanize_duration(seconds)
+      case seconds.abs
+      when 0..59       then "#{seconds.abs}s"
+      when 60..3599    then "#{seconds.abs / 60}m"
+      when 3600..86399 then "#{seconds.abs / 3600}h"
+      else "#{seconds.abs / 86400}d"
+      end
+    end
+
+    def time_until(time)
+      return "n/a" unless time
+      seconds = (time - Time.now.utc).to_i
+      return "now" if seconds <= 0
+      "in #{humanize_duration(seconds)}"
+    end
+  end
+end

data/lib/solid_queue_tui/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidQueueTui
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/lib/solid_queue_tui/views/blocked_view.rb

@@ -4,47 +4,21 @@ module SolidQueueTui
   module Views
     class BlockedView
       include Filterable
-
-
-      LOAD_THRESHOLD = 10
+      include Paginatable
+      include FormattingHelpers
 
       def initialize(tui)
         @tui = tui
-        @table_state = RatatuiRuby::TableState.new(nil)
-        @table_state.select(0)
-        @selected_row = 0
-        @jobs = []
-        @total_count = nil
-        @all_loaded = false
+        init_pagination
         init_filter
       end
 
       def update(jobs:)
-        @jobs = jobs
-        @all_loaded = jobs.size < SolidQueueTui.page_size
-        @selected_row = @selected_row.clamp(0, [@jobs.size - 1, 0].max)
-        @table_state.select(@selected_row)
+        update_items(jobs)
       end
 
       def append(jobs:)
-        @jobs.concat(jobs)
-        @all_loaded = jobs.size < SolidQueueTui.page_size
-      end
-
-      def total_count=(count)
-        @total_count = count
-      end
-
-      def current_offset
-        @jobs.size
-      end
-
-      def reset_pagination!
-        @jobs = []
-        @total_count = nil
-        @all_loaded = false
-        @selected_row = 0
-        @table_state.select(0)
+        append_items(jobs)
       end
 
       def render(frame, area)
@@ -72,11 +46,6 @@ module SolidQueueTui
         end
       end
 
-      def selected_item
-        return nil if @jobs.empty? || @selected_row >= @jobs.size
-        @jobs[@selected_row]
-      end
-
       def bindings
         if filter_mode?
           filter_bindings
@@ -85,8 +54,9 @@ module SolidQueueTui
             { key: "j/k", action: "Navigate" },
             { key: "Enter", action: "Detail" },
             { key: "/", action: "Filter" },
+            clear_filter_binding,
             { key: "G/g", action: "Bottom/Top" }
-          ]
+          ].compact
         end
       end
 
@@ -100,10 +70,6 @@ module SolidQueueTui
 
       private
 
-      def needs_more?
-        !@all_loaded && @selected_row >= @jobs.size - LOAD_THRESHOLD
-      end
-
       def handle_normal_input(event)
         case event
         in { type: :key, code: "j" } | { type: :key, code: "up" }
@@ -119,32 +85,13 @@ module SolidQueueTui
         in { type: :key, code: "/" }
           enter_filter_mode
           nil
-        in { type: :key, code: "esc" }
+        in { type: :key, code: "c" }
           clear_filter
         else
           nil
         end
       end
 
-      def move_selection(delta)
-        return if @jobs.empty?
-        @selected_row = (@selected_row + delta).clamp(0, @jobs.size - 1)
-        @table_state.select(@selected_row)
-        :load_more if needs_more?
-      end
-
-      def jump_to_top
-        @selected_row = 0
-        @table_state.select(0)
-      end
-
-      def jump_to_bottom
-        return if @jobs.empty?
-        @selected_row = @jobs.size - 1
-        @table_state.select(@selected_row)
-        return :load_more if needs_more?
-      end
-
       def render_table(frame, area)
         columns = [
           { key: :id,              label: "ID",              width: 8 },
@@ -156,7 +103,7 @@ module SolidQueueTui
           { key: :blocked_since,   label: "BLOCKED SINCE",    width: 14 }
         ]
 
-        rows = @jobs.map do |job|
+        rows = items.map do |job|
           {
             id: job.id,
             queue_name: job.queue_name,
@@ -181,21 +128,6 @@ module SolidQueueTui
         table.render(frame, area, @table_state)
       end
 
-      def format_time(time)
-        return "n/a" unless time
-        time.strftime("%Y-%m-%d %H:%M:%S")
-      end
-
-      def time_ago(time)
-        return "n/a" unless time
-        seconds = (Time.now.utc - time).to_i
-        case seconds
-        when 0..59       then "#{seconds}s ago"
-        when 60..3599    then "#{seconds / 60}m ago"
-        when 3600..86399 then "#{seconds / 3600}h ago"
-        else "#{seconds / 86400}d ago"
-        end
-      end
     end
   end
 end

data/lib/solid_queue_tui/views/concerns/confirmable.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Views
+    module Confirmable
+      def init_confirm
+        @confirm_action = nil
+      end
+
+      def confirm_mode? = !!@confirm_action
+
+      def confirm_bindings
+        [{ key: "y", action: "Confirm" }, { key: "n/Esc", action: "Cancel" }]
+      end
+
+      def handle_confirm_input(event)
+        case event
+        in { type: :key, code: "y" }
+          action = @confirm_action
+          @confirm_action = nil
+          execute_confirm_action(action)
+        in { type: :key, code: "n" } | { type: :key, code: "esc" }
+          @confirm_action = nil
+          nil
+        else
+          nil
+        end
+      end
+
+      def render_confirm_popup(frame, area)
+        popup_area = area.centered(
+          @tui.constraint_percentage(50),
+          @tui.constraint_length(5)
+        )
+        frame.render_widget(@tui.clear(), popup_area)
+        frame.render_widget(
+          @tui.paragraph(
+            text: " #{confirm_message}",
+            style: @tui.style(fg: :yellow, modifiers: [:bold]),
+            block: @tui.block(
+              title: " Confirm ",
+              title_style: @tui.style(fg: :red, modifiers: [:bold]),
+              borders: [:all],
+              border_type: :rounded,
+              border_style: @tui.style(fg: :red)
+            )
+          ),
+          popup_area
+        )
+      end
+    end
+  end
+end