solid_queue_tui 0.1.0

data/lib/solid_queue_tui/views/in_progress_view.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Views
+    class InProgressView
+      def initialize(tui)
+        @tui = tui
+        @table_state = RatatuiRuby::TableState.new(nil)
+        @table_state.select(0)
+        @selected_row = 0
+        @jobs = []
+      end
+
+      def update(jobs:)
+        @jobs = jobs
+        @selected_row = @selected_row.clamp(0, [@jobs.size - 1, 0].max)
+        @table_state.select(@selected_row)
+      end
+
+      def render(frame, area)
+        columns = [
+          { key: :id,         label: "ID",        width: 8 },
+          { key: :queue_name, label: "QUEUE",      width: 14 },
+          { key: :class_name, label: "CLASS",      width: :fill },
+          { key: :priority,   label: "PRI",        width: 5 },
+          { key: :worker_id,  label: "WORKER",     width: 8 },
+          { key: :started_at, label: "STARTED",    width: 12 }
+        ]
+
+        rows = @jobs.map do |job|
+          {
+            id: job.id,
+            queue_name: job.queue_name,
+            class_name: job.class_name,
+            priority: job.priority,
+            worker_id: job.worker_id || "n/a",
+            started_at: time_ago(job.started_at)
+          }
+        end
+
+        table = Components::JobTable.new(
+          @tui,
+          title: "In Progress",
+          columns: columns,
+          rows: rows,
+          selected_row: @selected_row,
+          empty_message: "No jobs currently in progress"
+        )
+
+        table.render(frame, area, @table_state)
+      end
+
+      def handle_input(event)
+        case event
+        in { type: :key, code: "j" } | { type: :key, code: "up" }
+          move_selection(-1)
+        in { type: :key, code: "k" } | { type: :key, code: "down" }
+          move_selection(1)
+        in { type: :key, code: "g" }
+          jump_to_top
+        in { type: :key, code: "G" }
+          jump_to_bottom
+        else
+          nil
+        end
+      end
+
+      def selected_item
+        return nil if @jobs.empty? || @selected_row >= @jobs.size
+        @jobs[@selected_row]
+      end
+
+      def bindings
+        [
+          { key: "j/k", action: "Navigate" },
+          { key: "Enter", action: "Detail" },
+          { key: "G/g", action: "Bottom/Top" }
+        ]
+      end
+
+      def breadcrumb = "in-progress"
+
+      private
+
+      def move_selection(delta)
+        return if @jobs.empty?
+        @selected_row = (@selected_row + delta).clamp(0, @jobs.size - 1)
+        @table_state.select(@selected_row)
+      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)
+      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/job_detail_view.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Views
+    class JobDetailView
+      def initialize(tui)
+        @tui = tui
+        @job = nil
+        @failed_job = nil
+        @scroll_offset = 0
+      end
+
+      def show(job: nil, failed_job: nil)
+        @job = job
+        @failed_job = failed_job
+        @scroll_offset = 0
+        @active = true
+      end
+
+      def hide
+        @active = false
+        @job = nil
+        @failed_job = nil
+      end
+
+      def active? = @active
+
+      def render(frame, area)
+        return unless @active
+
+        # Render an overlay with padding
+        inner = shrink_area(area, 4, 2)
+
+        frame.render_widget(@tui.paragraph(text: ""), inner) # clear background
+
+        if @failed_job
+          render_failed_detail(frame, inner)
+        elsif @job
+          render_job_detail(frame, inner)
+        end
+      end
+
+      def handle_input(event)
+        case event
+        in { type: :key, code: "esc" } | { type: :key, code: "q" }
+          hide
+          nil
+        in { type: :key, code: "j" } | { type: :key, code: "up" }
+          @scroll_offset = [@scroll_offset - 1, 0].max
+          nil
+        in { type: :key, code: "k" } | { type: :key, code: "down" }
+          @scroll_offset += 1
+          nil
+        in { type: :key, code: "R" }
+          if @failed_job
+            Actions::RetryJob.call(@failed_job.id)
+            hide
+            :refresh
+          end
+        in { type: :key, code: "D" }
+          if @failed_job
+            Actions::DiscardJob.call(@failed_job.id)
+            hide
+            :refresh
+          end
+        else
+          nil
+        end
+      end
+
+      def bindings
+        bindings = [
+          { key: "Esc", action: "Close" },
+          { key: "j/k", action: "Scroll" }
+        ]
+        if @failed_job
+          bindings += [
+            { key: "R", action: "Retry" },
+            { key: "D", action: "Discard" }
+          ]
+        end
+        bindings
+      end
+
+      def breadcrumb
+        if @failed_job
+          "failed:#{@failed_job.job_id}"
+        elsif @job
+          "jobs:#{@job.id}"
+        else
+          "detail"
+        end
+      end
+
+      private
+
+      def render_failed_detail(frame, area)
+        lines = []
+
+        lines << section_header("Job Information")
+        lines << detail_line("Job ID", @failed_job.job_id.to_s)
+        lines << detail_line("Active Job ID", @failed_job.active_job_id || "n/a")
+        lines << detail_line("Class", @failed_job.class_name)
+        lines << detail_line("Queue", @failed_job.queue_name)
+        lines << detail_line("Priority", @failed_job.priority.to_s)
+        lines << detail_line("Created At", format_time(@failed_job.created_at))
+        lines << detail_line("Failed At", format_time(@failed_job.failed_at))
+        lines << empty_line
+
+        lines << section_header("Error Details")
+        lines << detail_line("Exception", @failed_job.error_class)
+        lines << detail_line("Message", @failed_job.error_message)
+        lines << empty_line
+
+        if @failed_job.backtrace.is_a?(Array) && !@failed_job.backtrace.empty?
+          lines << section_header("Backtrace")
+          @failed_job.backtrace.first(30).each do |bt_line|
+            lines << @tui.text_line(spans: [
+              @tui.text_span(content: "  #{bt_line}", style: @tui.style(fg: :dark_gray))
+            ])
+          end
+          lines << empty_line
+        end
+
+        if @failed_job.arguments.is_a?(Hash) || @failed_job.arguments.is_a?(Array)
+          lines << section_header("Arguments")
+          args_str = JSON.pretty_generate(@failed_job.arguments) rescue @failed_job.arguments.to_s
+          args_str.split("\n").each do |arg_line|
+            lines << @tui.text_line(spans: [
+              @tui.text_span(content: "  #{arg_line}", style: @tui.style(fg: :white))
+            ])
+          end
+        end
+
+        # Apply scroll offset
+        visible_lines = lines.drop(@scroll_offset)
+
+        frame.render_widget(
+          @tui.paragraph(
+            text: visible_lines,
+            block: @tui.block(
+              title: " Failed Job ##{@failed_job.job_id} — #{@failed_job.class_name} ",
+              title_style: @tui.style(fg: :red, modifiers: [:bold]),
+              titles: [
+                { content: " Esc:Close  R:Retry  D:Discard ",
+                  position: :bottom, alignment: :right }
+              ],
+              borders: [:all],
+              border_type: :rounded,
+              border_style: @tui.style(fg: :red),
+              style: @tui.style(fg: :white)
+            )
+          ),
+          area
+        )
+      end
+
+      def render_job_detail(frame, area)
+        lines = []
+
+        lines << section_header("Job Information")
+        lines << detail_line("ID", @job.id.to_s)
+        lines << detail_line("Active Job ID", @job.active_job_id || "n/a")
+        lines << detail_line("Class", @job.class_name)
+        lines << detail_line("Queue", @job.queue_name)
+        lines << detail_line("Priority", @job.priority.to_s)
+        lines << detail_line("Status", @job.status)
+        lines << detail_line("Created At", format_time(@job.created_at))
+        lines << detail_line("Scheduled At", format_time(@job.scheduled_at))
+        lines << detail_line("Finished At", format_time(@job.finished_at))
+
+        if @job.arguments.is_a?(Hash) || @job.arguments.is_a?(Array)
+          lines << empty_line
+          lines << section_header("Arguments")
+          args_str = JSON.pretty_generate(@job.arguments) rescue @job.arguments.to_s
+          args_str.split("\n").each do |arg_line|
+            lines << @tui.text_line(spans: [
+              @tui.text_span(content: "  #{arg_line}", style: @tui.style(fg: :white))
+            ])
+          end
+        end
+
+        visible_lines = lines.drop(@scroll_offset)
+
+        frame.render_widget(
+          @tui.paragraph(
+            text: visible_lines,
+            block: @tui.block(
+              title: " Job ##{@job.id} — #{@job.class_name} ",
+              title_style: @tui.style(fg: :cyan, modifiers: [:bold]),
+              titles: [
+                { content: " Esc:Close ",
+                  position: :bottom, alignment: :right }
+              ],
+              borders: [:all],
+              border_type: :rounded,
+              border_style: @tui.style(fg: :cyan),
+              style: @tui.style(fg: :white)
+            )
+          ),
+          area
+        )
+      end
+
+      def section_header(title)
+        @tui.text_line(spans: [
+          @tui.text_span(content: "  ── #{title} ", style: @tui.style(fg: :cyan, modifiers: [:bold]))
+        ])
+      end
+
+      def detail_line(label, value)
+        @tui.text_line(spans: [
+          @tui.text_span(content: "  #{label.ljust(16)}", style: @tui.style(fg: :dark_gray)),
+          @tui.text_span(content: value.to_s, style: @tui.style(fg: :white))
+        ])
+      end
+
+      def empty_line
+        @tui.text_line(spans: [
+          @tui.text_span(content: "", style: @tui.style(fg: :white))
+        ])
+      end
+
+      def format_time(time)
+        return "n/a" unless time
+        time.strftime("%Y-%m-%d %H:%M:%S UTC")
+      end
+
+      def shrink_area(area, h_pad, v_pad)
+        # Create a smaller area centered in the given area
+        # This is an approximation - the actual implementation depends on ratatui_ruby's Rect API
+        area
+      end
+    end
+  end
+end

data/lib/solid_queue_tui/views/processes_view.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Views
+    class ProcessesView
+      KIND_COLORS = {
+        "Worker" => :green,
+        "Dispatcher" => :yellow,
+        "Scheduler" => :blue
+      }.freeze
+
+      def initialize(tui)
+        @tui = tui
+        @table_state = RatatuiRuby::TableState.new(nil)
+        @table_state.select(0)
+        @selected_row = 0
+        @processes = []
+      end
+
+      def update(processes:)
+        @processes = processes
+        @selected_row = @selected_row.clamp(0, [@processes.size - 1, 0].max)
+        @table_state.select(@selected_row)
+      end
+
+      def render(frame, area)
+        columns = [
+          { key: :id,        label: "ID",        width: 6 },
+          { key: :kind,      label: "KIND",       width: 12 },
+          { key: :hostname,  label: "HOSTNAME",   width: :fill },
+          { key: :pid,       label: "PID",        width: 8 },
+          { key: :name,      label: "NAME",       width: :fill },
+          { key: :queues,    label: "QUEUES",     width: :fill },
+          { key: :heartbeat, label: "HEARTBEAT",  width: 12 },
+          { key: :uptime,    label: "UPTIME",     width: 10 },
+          { key: :status,    label: "STATUS",     width: 8 }
+        ]
+
+        rows = @processes.map do |proc|
+          alive = proc.alive?
+
+          {
+            id: proc.id,
+            kind: proc.kind,
+            hostname: proc.hostname || "n/a",
+            pid: proc.pid,
+            name: proc.name || "n/a",
+            queues: Array(proc.queues).join(", "),
+            heartbeat: time_ago(proc.last_heartbeat_at),
+            uptime: format_duration(proc.uptime),
+            status: alive ? "alive" : "dead"
+          }
+        end
+
+        table = Components::JobTable.new(
+          @tui,
+          title: "Processes",
+          columns: columns,
+          rows: rows,
+          selected_row: @selected_row,
+          empty_message: "No active processes — is Solid Queue running?"
+        )
+
+        table.render(frame, area, @table_state)
+      end
+
+      def handle_input(event)
+        case event
+        in { type: :key, code: "j" } | { type: :key, code: "up" }
+          move_selection(-1)
+        in { type: :key, code: "k" } | { type: :key, code: "down" }
+          move_selection(1)
+        in { type: :key, code: "g" }
+          jump_to_top
+        in { type: :key, code: "G" }
+          jump_to_bottom
+        else
+          nil
+        end
+      end
+
+      def selected_item
+        return nil if @processes.empty? || @selected_row >= @processes.size
+        @processes[@selected_row]
+      end
+
+      def bindings
+        [
+          { key: "j/k", action: "Navigate" },
+          { key: "Enter", action: "Detail" },
+          { key: "G/g", action: "Bottom/Top" }
+        ]
+      end
+
+      def breadcrumb = "processes"
+
+      private
+
+      def move_selection(delta)
+        return if @processes.empty?
+        @selected_row = (@selected_row + delta).clamp(0, @processes.size - 1)
+        @table_state.select(@selected_row)
+      end
+
+      def jump_to_top
+        @selected_row = 0
+        @table_state.select(0)
+      end
+
+      def jump_to_bottom
+        return if @processes.empty?
+        @selected_row = @processes.size - 1
+        @table_state.select(@selected_row)
+      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
+
+      def format_duration(seconds)
+        return "n/a" unless seconds
+        seconds = seconds.to_i
+        if 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
+    end
+  end
+end

data/lib/solid_queue_tui/views/queues_view.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Views
+    class QueuesView
+      def initialize(tui)
+        @tui = tui
+        @table_state = RatatuiRuby::TableState.new(nil)
+        @table_state.select(0)
+        @selected_row = 0
+        @queues = []
+      end
+
+      def update(queues:)
+        @queues = queues
+        @selected_row = @selected_row.clamp(0, [@queues.size - 1, 0].max)
+        @table_state.select(@selected_row)
+      end
+
+      def render(frame, area)
+        columns = [
+          { key: :name,   label: "QUEUE",   width: :fill },
+          { key: :size,   label: "SIZE",    width: 10 },
+          { key: :status, label: "STATUS",  width: 10, color_by: :status }
+        ]
+
+        rows = @queues.map do |q|
+          {
+            name: q.name,
+            size: q.size,
+            status: q.paused ? "paused" : "active"
+          }
+        end
+
+        table = Components::JobTable.new(
+          @tui,
+          title: "Queues",
+          columns: columns,
+          rows: rows,
+          selected_row: @selected_row,
+          empty_message: "No queues found"
+        )
+
+        table.render(frame, area, @table_state)
+      end
+
+      def handle_input(event)
+        case event
+        in { type: :key, code: "j" } | { type: :key, code: "up" }
+          move_selection(-1)
+        in { type: :key, code: "k" } | { type: :key, code: "down" }
+          move_selection(1)
+        in { type: :key, code: "g" }
+          jump_to_top
+        in { type: :key, code: "G" }
+          jump_to_bottom
+        else
+          nil
+        end
+      end
+
+      def selected_item
+        return nil if @queues.empty? || @selected_row >= @queues.size
+        @queues[@selected_row]
+      end
+
+      def bindings
+        [
+          { key: "j/k", action: "Navigate" },
+          { key: "G/g", action: "Bottom/Top" }
+        ]
+      end
+
+      def breadcrumb = "queues"
+
+      private
+
+      def move_selection(delta)
+        return if @queues.empty?
+        @selected_row = (@selected_row + delta).clamp(0, @queues.size - 1)
+        @table_state.select(@selected_row)
+      end
+
+      def jump_to_top
+        @selected_row = 0
+        @table_state.select(0)
+      end
+
+      def jump_to_bottom
+        return if @queues.empty?
+        @selected_row = @queues.size - 1
+        @table_state.select(@selected_row)
+      end
+    end
+  end
+end