solid_queue_tui 0.1.0

data/lib/solid_queue_tui/cli.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module SolidQueueTui
+  class CLI
+    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
+
+    def self.parse_options(args)
+      options = {}
+
+      OptionParser.new do |opts|
+        opts.banner = "Usage: sqtui [options]"
+        opts.separator ""
+        opts.separator "Options:"
+
+        opts.on("--dev", "Enable hot-reload (watches lib/ for changes)") do
+          options[:dev] = true
+        end
+
+        opts.on("-v", "--version", "Show version") do
+          puts "sqtui v#{SolidQueueTui::VERSION}"
+          exit
+        end
+
+        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"
+          exit
+        end
+      end.parse!(args)
+
+      options
+    end
+  end
+end

data/lib/solid_queue_tui/components/header.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Components
+    class Header
+      LOGO = [
+        " ____        _ _     _    ___                        ",
+        "/ ___|  ___ | (_) __| |  / _ \\ _   _  ___ _   _  ___ ",
+        "\\___ \\ / _ \\| | |/ _` | | | | | | | |/ _ \\ | | |/ _ \\",
+        " ___) | (_) | | | (_| | | |_| | |_| |  __/ |_| |  __/",
+        "|____/ \\___/|_|_|\\__,_|  \\___/\\__,_|\\___|\\__,_|\\___|"
+      ].freeze
+
+      VIEWS = [
+        { key: "1", label: "Dashboard" },
+        { key: "2", label: "Queues" },
+        { key: "3", label: "Failed" },
+        { key: "4", label: "In Progress" },
+        { key: "5", label: "Blocked" },
+        { key: "6", label: "Scheduled" },
+        { key: "7", label: "Finished" },
+        { key: "8", label: "Workers" }
+      ].freeze
+
+      def initialize(tui, current_view:)
+        @tui = tui
+        @current_view = current_view
+      end
+
+      def render(frame, area)
+        left_area, right_area = @tui.layout_split(
+          area,
+          direction: :horizontal,
+          constraints: [
+            @tui.constraint_percentage(50),
+            @tui.constraint_percentage(50)
+          ]
+        )
+
+        render_info(frame, left_area)
+        render_nav(frame, right_area)
+      end
+
+      private
+
+      def render_info(frame, area)
+        lines = LOGO.map do |logo_line|
+          @tui.text_line(spans: [
+            @tui.text_span(content: " #{logo_line}", style: @tui.style(fg: :red, modifiers: [:bold]))
+          ])
+        end
+
+        lines << @tui.text_line(spans: [
+          @tui.text_span(content: " v#{VERSION}", style: @tui.style(fg: :dark_gray))
+        ])
+
+        frame.render_widget(
+          @tui.paragraph(text: lines),
+          area
+        )
+      end
+
+      def render_nav(frame, area)
+        spans = [
+          @tui.text_span(content: " ", style: @tui.style(fg: :white))
+        ]
+
+        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] : []
+            )
+          )
+          spans << @tui.text_span(content: "  ", style: @tui.style(fg: :white))
+        end
+
+        lines = [
+          @tui.text_line(spans: 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))
+          ], alignment: :right)
+        ]
+
+        frame.render_widget(
+          @tui.paragraph(text: lines),
+          area
+        )
+      end
+
+    end
+  end
+end

data/lib/solid_queue_tui/components/help_bar.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Components
+    class HelpBar
+      DEFAULT_BINDINGS = [
+        { key: "q", action: "Quit" },
+        { key: "r", action: "Refresh" },
+        { key: "Tab", action: "Next View" },
+        { key: "j/k", action: "Navigate" },
+        { key: "/", action: "Filter" },
+        { key: "Esc", action: "Clear" }
+      ].freeze
+
+      def initialize(tui, breadcrumb:, bindings: nil, status: nil)
+        @tui = tui
+        @breadcrumb = breadcrumb
+        @bindings = bindings || DEFAULT_BINDINGS
+        @status = status
+      end
+
+      def render(frame, area)
+        left, right = @tui.layout_split(
+          area,
+          direction: :horizontal,
+          constraints: [
+            @tui.constraint_percentage(30),
+            @tui.constraint_percentage(70)
+          ]
+        )
+
+        render_breadcrumb(frame, left)
+        render_bindings(frame, right)
+      end
+
+      private
+
+      def render_breadcrumb(frame, area)
+        spans = [
+          @tui.text_span(content: " <", style: @tui.style(fg: :dark_gray)),
+          @tui.text_span(content: @breadcrumb, style: @tui.style(fg: :yellow, modifiers: [:bold])),
+          @tui.text_span(content: ">", style: @tui.style(fg: :dark_gray))
+        ]
+
+        if @status
+          spans << @tui.text_span(content: "  #{@status}", style: @tui.style(fg: :dark_gray))
+        end
+
+        frame.render_widget(
+          @tui.paragraph(text: [@tui.text_line(spans: spans)]),
+          area
+        )
+      end
+
+      def render_bindings(frame, area)
+        spans = []
+
+        @bindings.each_with_index do |binding, idx|
+          spans << @tui.text_span(
+            content: binding[:key],
+            style: @tui.style(fg: :cyan, modifiers: [:bold])
+          )
+          spans << @tui.text_span(
+            content: ":#{binding[:action]}",
+            style: @tui.style(fg: :dark_gray)
+          )
+          spans << @tui.text_span(content: "  ", style: @tui.style(fg: :white)) if idx < @bindings.size - 1
+        end
+
+        frame.render_widget(
+          @tui.paragraph(text: [@tui.text_line(spans: spans, alignment: :right)]),
+          area
+        )
+      end
+    end
+  end
+end

data/lib/solid_queue_tui/components/job_table.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Components
+    class JobTable
+      STATUS_COLORS = {
+        "ready" => :green,
+        "claimed" => :yellow,
+        "scheduled" => :blue,
+        "failed" => :red,
+        "blocked" => :magenta,
+        "completed" => :dark_gray,
+        "active" => :green,
+        "paused" => :red,
+        "unknown" => :white
+      }.freeze
+
+      def initialize(tui, title:, columns:, rows:, selected_row: nil, empty_message: "No data")
+        @tui = tui
+        @title = title
+        @columns = columns
+        @rows = rows
+        @selected_row = selected_row
+        @empty_message = empty_message
+      end
+
+      def render(frame, area, table_state)
+        if @rows.empty?
+          render_empty(frame, area)
+          return
+        end
+
+        render_table(frame, area, table_state)
+      end
+
+      private
+
+      def title_text
+        text = " #{@title} [#{@rows.size}]"
+        text += "  #{@selected_row + 1}/#{@rows.size}" if @selected_row && @rows.size > 0
+        text + " "
+      end
+
+      def render_table(frame, area, table_state)
+        widths = @columns.map do |col|
+          case col[:width]
+          when :fill then @tui.constraint_fill(1)
+          when Integer then @tui.constraint_length(col[:width])
+          else @tui.constraint_length(12)
+          end
+        end
+
+        header = @columns.map { |col| col[:label] }
+
+        table = @tui.table(
+          rows: build_rows,
+          header: header,
+          widths: widths,
+          selected_row: @selected_row,
+          row_highlight_style: @tui.style(fg: :black, bg: :cyan, modifiers: [:bold]),
+          highlight_symbol: " > ",
+          highlight_spacing: :always,
+          column_spacing: 1,
+          style: @tui.style(fg: :white),
+          block: @tui.block(
+            title: title_text,
+            title_style: @tui.style(fg: :yellow, modifiers: [:bold]),
+            borders: [:all],
+            border_type: :rounded,
+            border_style: @tui.style(fg: :dark_gray)
+          )
+        )
+
+        frame.render_stateful_widget(table, area, table_state)
+      end
+
+      def build_rows
+        @rows.map do |row|
+          cells = @columns.map do |col|
+            value = row[col[:key]]
+            style = cell_style(col, value)
+
+            if style
+              @tui.table_cell(content: value.to_s, style: style)
+            else
+              value.to_s
+            end
+          end
+
+          @tui.table_row(cells: cells)
+        end
+      end
+
+      def cell_style(col, value)
+        if col[:color_by] == :status
+          color = STATUS_COLORS[value.to_s.downcase] || :white
+          @tui.style(fg: color, modifiers: [:bold])
+        elsif col[:color]
+          @tui.style(fg: col[:color])
+        end
+      end
+
+      def render_empty(frame, area)
+        frame.render_widget(
+          @tui.paragraph(
+            text: @empty_message,
+            alignment: :center,
+            style: @tui.style(fg: :dark_gray),
+            block: @tui.block(
+              title: " #{@title} ",
+              title_style: @tui.style(fg: :yellow, modifiers: [:bold]),
+              borders: [:all],
+              border_type: :rounded,
+              border_style: @tui.style(fg: :dark_gray)
+            )
+          ),
+          area
+        )
+      end
+    end
+  end
+end

data/lib/solid_queue_tui/connection.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "yaml"
+
+module SolidQueueTui
+  class Connection
+    CONFIG_FILE = "config/solid_tui.yml"
+
+    # Loads config, establishes the DB connection, and returns the parsed config hash.
+    def self.establish!
+      config = load_config
+
+      url = config["database_url"]
+      raise ConnectionError, <<~MSG unless url
+        No database_url found in #{CONFIG_FILE}.
+
+        Create #{CONFIG_FILE} with:
+          database_url: postgres://user:pass@localhost/myapp_queue
+          refresh: 2
+      MSG
+
+      ActiveRecord::Base.establish_connection(url)
+      verify_solid_queue_tables!
+
+      config
+    end
+
+    def self.load_config
+      path = File.join(Dir.pwd, CONFIG_FILE)
+
+      unless File.exist?(path)
+        raise ConnectionError, <<~MSG
+          Config file not found: #{CONFIG_FILE}
+
+          Create #{CONFIG_FILE} with:
+            database_url: postgres://user:pass@localhost/myapp_queue
+            refresh: 2
+        MSG
+      end
+
+      YAML.safe_load(File.read(path), permitted_classes: [Symbol]) || {}
+    end
+
+    def self.verify_solid_queue_tables!
+      conn = ActiveRecord::Base.connection
+      required = %w[solid_queue_jobs solid_queue_ready_executions]
+      missing = required.reject { |t| conn.table_exists?(t) }
+
+      unless missing.empty?
+        raise ConnectionError, "Missing Solid Queue tables: #{missing.join(', ')}. " \
+                               "Is this a Solid Queue database?"
+      end
+    end
+
+    class ConnectionError < StandardError; end
+  end
+end

data/lib/solid_queue_tui/data/failed_query.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Data
+    class FailedQuery
+      FailedJob = Struct.new(
+        :id, :job_id, :queue_name, :class_name, :priority,
+        :error_class, :error_message, :backtrace,
+        :active_job_id, :arguments, :failed_at, :created_at,
+        keyword_init: true
+      )
+
+      def self.fetch(filter: nil, limit: 200)
+        conn = ActiveRecord::Base.connection
+
+        sql = <<~SQL
+          SELECT
+            fe.id,
+            fe.job_id,
+            j.queue_name,
+            j.class_name,
+            j.priority,
+            j.active_job_id,
+            j.arguments,
+            j.created_at AS job_created_at,
+            fe.error,
+            fe.created_at AS failed_at
+          FROM solid_queue_failed_executions fe
+          JOIN solid_queue_jobs j ON j.id = fe.job_id
+        SQL
+
+        if filter && !filter.empty?
+          sql += " WHERE j.class_name LIKE #{conn.quote("%#{filter}%")}"
+        end
+
+        sql += " ORDER BY fe.created_at DESC LIMIT #{limit.to_i}"
+
+        rows = conn.select_all(sql)
+        rows.map do |row|
+          error = parse_json(row["error"])
+
+          FailedJob.new(
+            id: row["id"].to_i,
+            job_id: row["job_id"].to_i,
+            queue_name: row["queue_name"],
+            class_name: row["class_name"],
+            priority: row["priority"].to_i,
+            error_class: error["exception_class"] || error["class"] || "Unknown",
+            error_message: error["message"] || "No message",
+            backtrace: error["backtrace"] || [],
+            active_job_id: row["active_job_id"],
+            arguments: parse_json(row["arguments"]),
+            failed_at: parse_time(row["failed_at"]),
+            created_at: parse_time(row["job_created_at"])
+          )
+        end
+      rescue => e
+        []
+      end
+
+      def self.fetch_one(id)
+        conn = ActiveRecord::Base.connection
+
+        row = conn.select_one(<<~SQL)
+          SELECT
+            fe.id,
+            fe.job_id,
+            j.queue_name,
+            j.class_name,
+            j.priority,
+            j.active_job_id,
+            j.arguments,
+            j.created_at AS job_created_at,
+            fe.error,
+            fe.created_at AS failed_at
+          FROM solid_queue_failed_executions fe
+          JOIN solid_queue_jobs j ON j.id = fe.job_id
+          WHERE fe.id = #{conn.quote(id.to_i)}
+        SQL
+
+        return nil unless row
+
+        error = parse_json(row["error"])
+
+        FailedJob.new(
+          id: row["id"].to_i,
+          job_id: row["job_id"].to_i,
+          queue_name: row["queue_name"],
+          class_name: row["class_name"],
+          priority: row["priority"].to_i,
+          error_class: error["exception_class"] || error["class"] || "Unknown",
+          error_message: error["message"] || "No message",
+          backtrace: error["backtrace"] || [],
+          active_job_id: row["active_job_id"],
+          arguments: parse_json(row["arguments"]),
+          failed_at: parse_time(row["failed_at"]),
+          created_at: parse_time(row["job_created_at"])
+        )
+      rescue => e
+        nil
+      end
+
+      private_class_method def self.parse_json(value)
+        return {} if value.nil?
+        value.is_a?(Hash) || value.is_a?(Array) ? value : JSON.parse(value.to_s)
+      rescue JSON::ParserError
+        {}
+      end
+
+      private_class_method def self.parse_time(value)
+        return nil if value.nil?
+        value.is_a?(Time) ? value : Time.parse(value.to_s)
+      rescue
+        nil
+      end
+    end
+  end
+end