solid_queue_tui 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 969d0f0bb659a0568e476a7b6f9292a5f772217fc688cab1f55c23b505db4952
-  data.tar.gz: ec7edd7aca4a711ac044f3bdd2ea00dbf791980535341806b271256bc44ae21b
+  metadata.gz: ea9a6cc3e42df6d7c5f50f91ed2bbf360bbd3e65c9fabb6f53bcf649b69826f1
+  data.tar.gz: 3cd1c06f2c4ea19f2c59e0c5dc79962211d8f18b8200b4f46955910c2fcd78e6
 SHA512:
-  metadata.gz: 5c5484690f95c5b7602399255d40c32d398de508c6e0d9240d221e90d04d5efff4b78e4370e8df8bd8b2d71b17f92832746639e2a53323b1c9678bcf71a617d5
-  data.tar.gz: 6aa48617f392b62c597ad925746e008ef8f66ceb525f169fbbbfc904c7abd3551b77bd60b39af735b987bbd7a17fe14093859caf7eb9e55afdc9beab8be7d490
+  metadata.gz: 2364ad1bd990fca2ec78ad80a744c3d820e07b3add19dcbfcfeb88cebb5c07b47dc9b29acefafc27dac06a24b333cb11cd894ffba070435d4fbdcbb051d79941
+  data.tar.gz: af34ecfb3046c67d8aac92f227d37740130946ee5f3abb919b55c2d8edd86b40ba242970dc9bda05e2191c397e42548f200295f8259ca05653a7992fa5d3731a

data/exe/sqtui

@@ -1,6 +1,42 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "solid_queue_tui"
+# 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 "sqtui 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
+
+# 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.
+# 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/actions/discard_job.rb

@@ -4,28 +4,11 @@ module SolidQueueTui
   module Actions
     class DiscardJob
       def self.call(failed_execution_id)
-        conn = ActiveRecord::Base.connection
-
-        row = conn.select_one(
-          "SELECT fe.id, fe.job_id FROM solid_queue_failed_executions fe " \
-          "WHERE fe.id = #{conn.quote(failed_execution_id.to_i)}"
-        )
-        return false unless row
-
-        conn.transaction do
-          # Remove the failed execution
-          conn.execute(
-            "DELETE FROM solid_queue_failed_executions WHERE id = #{conn.quote(failed_execution_id.to_i)}"
-          )
-
-          # Mark the job as finished (discarded)
-          conn.execute(
-            "UPDATE solid_queue_jobs SET finished_at = #{conn.quote(Time.now.utc.iso8601)} " \
-            "WHERE id = #{conn.quote(row['job_id'])}"
-          )
-        end
-
+        fe = SolidQueue::FailedExecution.find(failed_execution_id)
+        fe.discard
         true
+      rescue ActiveRecord::RecordNotFound
+        false
       rescue => e
         false
       end

data/lib/solid_queue_tui/actions/discard_scheduled_job.rb

@@ -4,30 +4,14 @@ module SolidQueueTui
   module Actions
     class DiscardScheduledJob
       def self.call(job_id)
-        conn = ActiveRecord::Base.connection
-
-        row = conn.select_one(
-          "SELECT se.id, se.job_id " \
-            "FROM solid_queue_scheduled_executions se " \
-            "WHERE se.job_id = #{conn.quote(job_id.to_i)}"
-        )
-        return false unless row
-
-        conn.transaction do
-          conn.execute(
-            "DELETE FROM solid_queue_scheduled_executions WHERE id = #{conn.quote(row['id'])}"
-          )
-
-          conn.execute(
-            "UPDATE solid_queue_jobs SET finished_at = #{conn.quote(Time.now.utc.iso8601)} " \
-              "WHERE id = #{conn.quote(row['job_id'])}"
-          )
-        end
-
+        se = SolidQueue::ScheduledExecution.find_by!(job_id: job_id)
+        se.discard
         true
+      rescue ActiveRecord::RecordNotFound
+        false
       rescue => e
         false
       end
     end
   end
-end
+end

data/lib/solid_queue_tui/actions/dispatch_scheduled_job.rb

@@ -4,32 +4,13 @@ module SolidQueueTui
   module Actions
     class DispatchScheduledJob
       def self.call(job_id)
-        conn = ActiveRecord::Base.connection
-
-        row = conn.select_one(
-          "SELECT se.id, se.job_id, j.queue_name, j.priority " \
-            "FROM solid_queue_scheduled_executions se " \
-            "JOIN solid_queue_jobs j ON j.id = se.job_id " \
-            "WHERE j.id = #{conn.quote(job_id.to_i)}"
-        )
-        return false unless row
-
-        conn.transaction do
-          conn.execute(
-            "INSERT INTO solid_queue_ready_executions (job_id, queue_name, priority, created_at) " \
-              "VALUES (#{conn.quote(row['job_id'])}, #{conn.quote(row['queue_name'])}, " \
-              "#{conn.quote(row['priority'])}, #{conn.quote(Time.now.utc.iso8601)})"
-          )
-
-          conn.execute(
-            "DELETE FROM solid_queue_scheduled_executions WHERE id = #{conn.quote(row['id'])}"
-          )
-        end
-
+        SolidQueue::ScheduledExecution.dispatch_jobs([job_id])
         true
+      rescue ActiveRecord::RecordNotFound
+        false
       rescue => e
         false
       end
     end
   end
-end
+end

data/lib/solid_queue_tui/actions/enqueue_recurring_task.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Actions
+    class EnqueueRecurringTask
+      def self.call(task_key)
+        task = SolidQueue::RecurringTask.find_by!(key: task_key)
+        task.enqueue(at: Time.now)
+      end
+    end
+  end
+end

data/lib/solid_queue_tui/actions/retry_job.rb

@@ -4,72 +4,27 @@ module SolidQueueTui
   module Actions
     class RetryJob
       def self.call(failed_execution_id)
-        conn = ActiveRecord::Base.connection
-
-        # Get the failed execution and its job
-        row = conn.select_one(
-          "SELECT fe.id, fe.job_id, j.queue_name, j.priority " \
-          "FROM solid_queue_failed_executions fe " \
-          "JOIN solid_queue_jobs j ON j.id = fe.job_id " \
-          "WHERE fe.id = #{conn.quote(failed_execution_id.to_i)}"
-        )
-        return false unless row
-
-        conn.transaction do
-          # Create a ready execution for the job
-          conn.execute(
-            "INSERT INTO solid_queue_ready_executions (job_id, queue_name, priority, created_at) " \
-            "VALUES (#{conn.quote(row['job_id'])}, #{conn.quote(row['queue_name'])}, " \
-            "#{conn.quote(row['priority'])}, #{conn.quote(Time.now.utc.iso8601)})"
-          )
-
-          # Remove the failed execution
-          conn.execute(
-            "DELETE FROM solid_queue_failed_executions WHERE id = #{conn.quote(failed_execution_id.to_i)}"
-          )
-
-          # Clear finished_at on the job
-          conn.execute(
-            "UPDATE solid_queue_jobs SET finished_at = NULL " \
-            "WHERE id = #{conn.quote(row['job_id'])}"
-          )
-        end
-
+        fe = SolidQueue::FailedExecution.find(failed_execution_id)
+        fe.retry
         true
+      rescue ActiveRecord::RecordNotFound
+        false
       rescue => e
         false
       end
 
-      def self.retry_all
-        conn = ActiveRecord::Base.connection
-
-        rows = conn.select_all(
-          "SELECT fe.id, fe.job_id, j.queue_name, j.priority " \
-          "FROM solid_queue_failed_executions fe " \
-          "JOIN solid_queue_jobs j ON j.id = fe.job_id"
-        )
-
-        count = 0
-        rows.each do |row|
-          conn.transaction do
-            conn.execute(
-              "INSERT INTO solid_queue_ready_executions (job_id, queue_name, priority, created_at) " \
-              "VALUES (#{conn.quote(row['job_id'])}, #{conn.quote(row['queue_name'])}, " \
-              "#{conn.quote(row['priority'])}, #{conn.quote(Time.now.utc.iso8601)})"
-            )
-            conn.execute(
-              "DELETE FROM solid_queue_failed_executions WHERE id = #{conn.quote(row['id'])}"
-            )
-            conn.execute(
-              "UPDATE solid_queue_jobs SET finished_at = NULL WHERE id = #{conn.quote(row['job_id'])}"
-            )
-            count += 1
-          end
-        rescue
-          next
-        end
+      def self.retry_all(filter: nil, queue: nil)
+        scope = SolidQueue::FailedExecution.joins(:job)
+        scope = scope.merge(SolidQueue::Job.where("class_name LIKE ?", "%#{filter}%")) if filter.present?
+        scope = scope.merge(SolidQueue::Job.where(queue_name: queue)) if queue.present?
+        count = scope.count
+        return 0 if count == 0
 
+        jobs = SolidQueue::Job.where(id: scope.select(:job_id))
+        SolidQueue::FailedExecution.retry_all(jobs)
         count
+      rescue => e
+        0
       end
     end
   end

data/lib/solid_queue_tui/actions/toggle_queue_pause.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Actions
+    class ToggleQueuePause
+      def self.call(queue_name)
+        queue = SolidQueue::Queue.find_by_name(queue_name)
+        if queue.paused?
+          queue.resume
+        else
+          queue.pause
+        end
+        true
+      rescue => e
+        false
+      end
+    end
+  end
+end

data/lib/solid_queue_tui/application.rb

@@ -12,9 +12,10 @@ module SolidQueueTui
     VIEW_BLOCKED     = 4
     VIEW_SCHEDULED   = 5
     VIEW_FINISHED    = 6
-    VIEW_WORKERS     = 7
+    VIEW_RECURRING   = 7
+    VIEW_WORKERS     = 8
 
-    VIEW_COUNT = 8
+    VIEW_COUNT = 9
 
     COMMAND_MAP = {
       "dashboard"   => VIEW_DASHBOARD,
@@ -24,6 +25,7 @@ module SolidQueueTui
       "blocked"     => VIEW_BLOCKED,
       "scheduled"   => VIEW_SCHEDULED,
       "finished"    => VIEW_FINISHED,
+      "recurring"   => VIEW_RECURRING,
       "workers"     => VIEW_WORKERS
     }.freeze
 
@@ -39,8 +41,7 @@ module SolidQueueTui
     end
 
     def run
-      config = Connection.establish!
-      @refresh_interval = config.fetch("refresh", 2).to_i
+      @refresh_interval = SolidQueueTui.refresh_interval
       setup_dev_reloader! if @dev
 
       RatatuiRuby.run do |tui|
@@ -69,6 +70,7 @@ module SolidQueueTui
         VIEW_BLOCKED     => Views::BlockedView.new(@tui),
         VIEW_SCHEDULED   => Views::ScheduledView.new(@tui),
         VIEW_FINISHED    => Views::FinishedView.new(@tui),
+        VIEW_RECURRING   => Views::RecurringTasksView.new(@tui),
         VIEW_WORKERS     => Views::ProcessesView.new(@tui)
       }
       @job_detail = Views::JobDetailView.new(@tui)
@@ -141,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
 
@@ -191,11 +200,17 @@ module SolidQueueTui
         switch_view(VIEW_FINISHED)
         return false
       in { type: :key, code: "8" }
+        switch_view(VIEW_RECURRING)
+        return false
+      in { type: :key, code: "9" }
         switch_view(VIEW_WORKERS)
         return false
       in { type: :key, code: "tab" }
         switch_view((@current_view + 1) % VIEW_COUNT)
         return false
+      in { type: :key, code: "back_tab" }
+        switch_view((@current_view - 1) % VIEW_COUNT)
+        return false
       in { type: :key, code: "enter" }
         open_detail
         return false
@@ -210,7 +225,11 @@ module SolidQueueTui
 
       # Pass to current view
       result = current_view.handle_input(event)
-      refresh_data! if result == :refresh
+      if result == :refresh
+        refresh_data!
+      elsif result == :load_more
+        load_more_data!
+      end
 
       false
     end
@@ -229,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
 
@@ -243,38 +272,94 @@ module SolidQueueTui
     end
 
     def refresh_data!
-      @stats = Data::Stats.fetch
       @last_refresh = Time.now
 
       case @current_view
       when VIEW_DASHBOARD
+        @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
-        filter = current_view.filter
-        failed_jobs = Data::FailedQuery.fetch(filter: filter)
+        f = current_view.filters
+        current_view.total_count = Data::FailedQuery.count(filter: f[:class_name], queue: f[:queue])
+        failed_jobs = Data::FailedQuery.fetch(filter: f[:class_name], queue: f[:queue], limit: SolidQueueTui.page_size, offset: 0)
         current_view.update(failed_jobs: failed_jobs)
       when VIEW_IN_PROGRESS
-        jobs = Data::JobsQuery.fetch(status: "claimed")
+        f = current_view.filters
+        current_view.total_count = Data::JobsQuery.count(status: "claimed", filter: f[:class_name], queue: f[:queue])
+        jobs = Data::JobsQuery.fetch(status: "claimed", filter: f[:class_name], queue: f[:queue], limit: SolidQueueTui.page_size, offset: 0)
         current_view.update(jobs: jobs)
       when VIEW_BLOCKED
-        jobs = Data::JobsQuery.fetch(status: "blocked")
+        f = current_view.filters
+        current_view.total_count = Data::JobsQuery.count(status: "blocked", filter: f[:class_name], queue: f[:queue])
+        jobs = Data::JobsQuery.fetch(status: "blocked", filter: f[:class_name], queue: f[:queue], limit: SolidQueueTui.page_size, offset: 0)
         current_view.update(jobs: jobs)
       when VIEW_SCHEDULED
-        jobs = Data::JobsQuery.fetch(status: "scheduled")
+        f = current_view.filters
+        current_view.total_count = Data::JobsQuery.count(status: "scheduled", filter: f[:class_name], queue: f[:queue])
+        jobs = Data::JobsQuery.fetch(status: "scheduled", filter: f[:class_name], queue: f[:queue], limit: SolidQueueTui.page_size, offset: 0)
         current_view.update(jobs: jobs)
       when VIEW_FINISHED
-        filter = current_view.respond_to?(:filter) ? current_view.filter : nil
-        jobs = Data::JobsQuery.fetch(status: "completed", filter: filter)
+        f = current_view.filters
+        current_view.total_count = Data::JobsQuery.count(status: "completed", filter: f[:class_name], queue: f[:queue])
+        jobs = Data::JobsQuery.fetch(status: "completed", filter: f[:class_name], queue: f[:queue], limit: SolidQueueTui.page_size, offset: 0)
         current_view.update(jobs: jobs)
+      when VIEW_RECURRING
+        tasks = Data::RecurringTasksQuery.fetch
+        current_view.update(tasks: tasks)
       when VIEW_WORKERS
         processes = Data::ProcessesQuery.fetch
         current_view.update(processes: processes)
       end
     rescue => e
-      # Silently handle refresh errors to keep TUI responsive
+      Rails.logger.tagged("SQTUI") { Rails.logger.error("refresh_data! error: #{e.class}: #{e.message}\n#{e.backtrace&.first(5)&.join("\n")}") } if defined?(Rails) && Rails.logger
+    end
+
+    def load_more_data!
+      view = current_view
+      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)
+        view.append(failed_jobs: more)
+      when VIEW_IN_PROGRESS
+        f = view.filters
+        more = Data::JobsQuery.fetch(status: "claimed", filter: f[:class_name], queue: f[:queue], limit: SolidQueueTui.page_size, offset: offset)
+        view.append(jobs: more)
+      when VIEW_BLOCKED
+        f = view.filters
+        more = Data::JobsQuery.fetch(status: "blocked", filter: f[:class_name], queue: f[:queue], limit: SolidQueueTui.page_size, offset: offset)
+        view.append(jobs: more)
+      when VIEW_SCHEDULED
+        f = view.filters
+        more = Data::JobsQuery.fetch(status: "scheduled", filter: f[:class_name], queue: f[:queue], limit: SolidQueueTui.page_size, offset: offset)
+        view.append(jobs: more)
+      when VIEW_FINISHED
+        f = view.filters
+        more = Data::JobsQuery.fetch(status: "completed", filter: f[:class_name], queue: f[:queue], limit: SolidQueueTui.page_size, offset: offset)
+        view.append(jobs: more)
+      end
+    rescue => e
+      Rails.logger.tagged("SQTUI") { Rails.logger.error("load_more_data! error: #{e.class}: #{e.message}") } if defined?(Rails) && Rails.logger
     end
 
     def setup_dev_reloader!
@@ -393,8 +478,9 @@ module SolidQueueTui
         ]),
         empty_line,
         help_section("Navigation"),
-        help_line("1-8", "Switch between views"),
+        help_line("1-9", "Switch between views"),
         help_line("Tab", "Next view"),
+        help_line("Shift + Tab", "Previous View"),
         help_line(":", "Command mode (:queues, :failed, ...)"),
         help_line("Esc", "Back to Dashboard"),
         help_line("j / Up", "Move selection up"),
@@ -418,12 +504,14 @@ module SolidQueueTui
         help_line("5", "Blocked — Concurrency-blocked jobs"),
         help_line("6", "Scheduled — Future scheduled jobs"),
         help_line("7", "Finished — Completed jobs"),
-        help_line("8", "Workers — Active processes"),
+        help_line("8", "Recurring — Recurring tasks"),
+        help_line("9", "Workers — Active processes"),
         empty_line,
         help_section("General"),
         help_line("?", "Toggle this help"),
         help_line("q", "Quit"),
-        help_line("Ctrl+C", "Force quit")
+        help_line("Ctrl+C", "Force quit"),
+        help_line("fn + select", "Select Text")
       ]
 
       frame.render_widget(

data/lib/solid_queue_tui/cli.rb

@@ -7,9 +7,6 @@ module SolidQueueTui
     def self.run(args)
       options = parse_options(args)
       Application.new(**options).run
-    rescue Connection::ConnectionError => e
-      $stderr.puts "Connection error: #{e.message}"
-      exit 1
     rescue Interrupt
       exit 0
     end
@@ -22,10 +19,22 @@ module SolidQueueTui
         opts.separator ""
         opts.separator "Options:"
 
-        opts.on("--dev", "Enable hot-reload (watches lib/ for changes)") do
+        opts.on("--dev", "Enable hot-reload (development only)") do
+          unless defined?(Rails) && Rails.env.development?
+            $stderr.puts "Error: --dev is only allowed in the development environment."
+            exit 1
+          end
           options[:dev] = true
         end
 
+        opts.on("--page-size N", Integer, "Number of rows per page (default: #{SolidQueueTui.page_size})") do |n|
+          SolidQueueTui.page_size = n
+        end
+
+        opts.on("--refresh-interval N", Integer, "Refresh interval in seconds (default: #{SolidQueueTui.refresh_interval})") do |n|
+          SolidQueueTui.refresh_interval = n
+        end
+
         opts.on("-v", "--version", "Show version") do
           puts "sqtui v#{SolidQueueTui::VERSION}"
           exit
@@ -34,10 +43,8 @@ module SolidQueueTui
         opts.on("-h", "--help", "Show this help") do
           puts opts
           puts ""
-          puts "Configuration:"
-          puts "  Create config/solid_tui.yml with:"
-          puts "    database_url: sqlite3:storage/queue.sqlite3"
-          puts "    refresh: 2"
+          puts "Run from your Rails app root directory."
+          puts "Requires solid_queue_tui in your Gemfile and Solid Queue configured."
           exit
         end
       end.parse!(args)

data/lib/solid_queue_tui/components/header.rb

@@ -4,11 +4,11 @@ module SolidQueueTui
   module Components
     class Header
       LOGO = [
-        " ____        _ _     _    ___                        ",
-        "/ ___|  ___ | (_) __| |  / _ \\ _   _  ___ _   _  ___ ",
-        "\\___ \\ / _ \\| | |/ _` | | | | | | | |/ _ \\ | | |/ _ \\",
-        " ___) | (_) | | | (_| | | |_| | |_| |  __/ |_| |  __/",
-        "|____/ \\___/|_|_|\\__,_|  \\___/\\__,_|\\___|\\__,_|\\___|"
+        " ____        _ _     _    ___                         ",
+        "/ ___|  ___ | (_) __| |  / _ \\  _   _  ___ _   _  ___",
+        "\\___ \\ / _ \\| | |/ _` | | | | || | | |/ _ \\ | | |/ _ \\",
+        " ___) | (_) | | | (_| | | |_| || |_| |  __/ |_| |  __/",
+        "|____/ \\___/|_|_|\\__,_|  \\__\\_\\ \\__,_|\\___|\\__,_|\\___|"
       ].freeze
 
       VIEWS = [
@@ -19,7 +19,8 @@ module SolidQueueTui
         { key: "5", label: "Blocked" },
         { key: "6", label: "Scheduled" },
         { key: "7", label: "Finished" },
-        { key: "8", label: "Workers" }
+        { key: "8", label: "Recurring" },
+        { key: "9", label: "Workers" }
       ].freeze
 
       def initialize(tui, current_view:)
@@ -61,36 +62,34 @@ module SolidQueueTui
       end
 
       def render_nav(frame, area)
-        spans = [
-          @tui.text_span(content: " ", style: @tui.style(fg: :white))
-        ]
+        tab_spans = []
 
         VIEWS.each_with_index do |view, idx|
           active = idx == @current_view
 
-          spans << @tui.text_span(
-            content: "<#{view[:key]}>",
-            style: @tui.style(fg: :cyan, modifiers: active ? [:bold] : [])
-          )
-          spans << @tui.text_span(
-            content: " #{view[:label]}",
-            style: @tui.style(
-              fg: active ? :yellow : :dark_gray,
-              modifiers: active ? [:bold, :underlined] : []
+          if active
+            tab_spans << @tui.text_span(
+              content: " #{view[:key]}·#{view[:label]} ",
+              style: @tui.style(fg: :cyan, modifiers: [:bold, :underlined])
+            )
+          else
+            tab_spans << @tui.text_span(
+              content: " #{view[:key]}·#{view[:label]} ",
+              style: @tui.style(fg: :dark_gray)
             )
-          )
-          spans << @tui.text_span(content: "  ", style: @tui.style(fg: :white))
+          end
+          tab_spans << @tui.text_span(content: " ", style: @tui.style(fg: :white))
         end
 
         lines = [
-          @tui.text_line(spans: spans, alignment: :right),
+          @tui.text_line(spans: tab_spans, alignment: :right),
           @tui.text_line(spans: [
-            @tui.text_span(content: "<?>", style: @tui.style(fg: :cyan)),
-            @tui.text_span(content: " Help  ", style: @tui.style(fg: :dark_gray)),
-            @tui.text_span(content: "<q>", style: @tui.style(fg: :cyan)),
-            @tui.text_span(content: " Quit  ", style: @tui.style(fg: :dark_gray)),
-            @tui.text_span(content: "<r>", style: @tui.style(fg: :cyan)),
-            @tui.text_span(content: " Refresh", style: @tui.style(fg: :dark_gray))
+            @tui.text_span(content: "<?> ", style: @tui.style(fg: :cyan)),
+            @tui.text_span(content: "Help  ", style: @tui.style(fg: :dark_gray)),
+            @tui.text_span(content: "<q> ", style: @tui.style(fg: :cyan)),
+            @tui.text_span(content: "Quit  ", style: @tui.style(fg: :dark_gray)),
+            @tui.text_span(content: "<r> ", style: @tui.style(fg: :cyan)),
+            @tui.text_span(content: "Refresh", style: @tui.style(fg: :dark_gray))
           ], alignment: :right)
         ]
 

data/lib/solid_queue_tui/components/help_bar.rb

@@ -7,6 +7,7 @@ module SolidQueueTui
         { key: "q", action: "Quit" },
         { key: "r", action: "Refresh" },
         { key: "Tab", action: "Next View" },
+        { Key: "Shift + Tab", action: "Previous View"},
         { key: "j/k", action: "Navigate" },
         { key: "/", action: "Filter" },
         { key: "Esc", action: "Clear" }