solid_queue_tui 0.1.0

data/lib/solid_queue_tui/data/jobs_query.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Data
+    class JobsQuery
+      Job = Struct.new(
+        :id, :queue_name, :class_name, :priority, :status,
+        :active_job_id, :concurrency_key, :arguments,
+        :scheduled_at, :finished_at, :created_at,
+        :started_at, :worker_id, :expires_at,
+        keyword_init: true
+      )
+
+      def self.fetch(status:, filter: nil, queue: nil, limit: 200)
+        case status
+        when "claimed"   then fetch_claimed(filter: filter, queue: queue, limit: limit)
+        when "blocked"   then fetch_blocked(filter: filter, queue: queue, limit: limit)
+        when "scheduled" then fetch_scheduled(filter: filter, queue: queue, limit: limit)
+        when "completed" then fetch_finished(filter: filter, queue: queue, limit: limit)
+        else []
+        end
+      rescue => e
+        []
+      end
+
+      def self.fetch_claimed(filter: nil, queue: nil, limit: 200)
+        conn = ActiveRecord::Base.connection
+
+        sql = <<~SQL
+          SELECT
+            j.id, j.queue_name, j.class_name, j.priority,
+            j.active_job_id, j.concurrency_key, j.created_at,
+            ce.process_id AS worker_id,
+            ce.created_at AS started_at
+          FROM solid_queue_claimed_executions ce
+          JOIN solid_queue_jobs j ON j.id = ce.job_id
+        SQL
+
+        conditions = []
+        conditions << "j.queue_name = #{conn.quote(queue)}" if queue
+        conditions << "j.class_name LIKE #{conn.quote("%#{filter}%")}" if filter && !filter.empty?
+
+        sql += " WHERE #{conditions.join(' AND ')}" unless conditions.empty?
+        sql += " ORDER BY ce.job_id ASC LIMIT #{limit.to_i}"
+
+        conn.select_all(sql).map do |row|
+          Job.new(
+            id: row["id"].to_i,
+            queue_name: row["queue_name"],
+            class_name: row["class_name"],
+            priority: row["priority"].to_i,
+            status: "claimed",
+            active_job_id: row["active_job_id"],
+            concurrency_key: row["concurrency_key"],
+            created_at: parse_time(row["created_at"]),
+            worker_id: row["worker_id"]&.to_i,
+            started_at: parse_time(row["started_at"])
+          )
+        end
+      end
+
+      def self.fetch_blocked(filter: nil, queue: nil, limit: 200)
+        conn = ActiveRecord::Base.connection
+
+        sql = <<~SQL
+          SELECT
+            j.id, j.queue_name, j.class_name, j.priority,
+            j.active_job_id, j.concurrency_key, j.created_at,
+            be.expires_at,
+            be.created_at AS blocked_since
+          FROM solid_queue_blocked_executions be
+          JOIN solid_queue_jobs j ON j.id = be.job_id
+        SQL
+
+        conditions = []
+        conditions << "j.queue_name = #{conn.quote(queue)}" if queue
+        conditions << "j.class_name LIKE #{conn.quote("%#{filter}%")}" if filter && !filter.empty?
+
+        sql += " WHERE #{conditions.join(' AND ')}" unless conditions.empty?
+        sql += " ORDER BY be.job_id ASC LIMIT #{limit.to_i}"
+
+        conn.select_all(sql).map do |row|
+          Job.new(
+            id: row["id"].to_i,
+            queue_name: row["queue_name"],
+            class_name: row["class_name"],
+            priority: row["priority"].to_i,
+            status: "blocked",
+            active_job_id: row["active_job_id"],
+            concurrency_key: row["concurrency_key"],
+            created_at: parse_time(row["blocked_since"]),
+            expires_at: parse_time(row["expires_at"])
+          )
+        end
+      end
+
+      # Scheduled: query from scheduled_executions JOIN jobs
+      def self.fetch_scheduled(filter: nil, queue: nil, limit: 200)
+        conn = ActiveRecord::Base.connection
+
+        sql = <<~SQL
+          SELECT
+            j.id, j.queue_name, j.class_name, j.priority,
+            j.active_job_id, j.arguments, j.created_at,
+            se.scheduled_at
+          FROM solid_queue_scheduled_executions se
+          JOIN solid_queue_jobs j ON j.id = se.job_id
+        SQL
+
+        conditions = []
+        conditions << "j.queue_name = #{conn.quote(queue)}" if queue
+        conditions << "j.class_name LIKE #{conn.quote("%#{filter}%")}" if filter && !filter.empty?
+
+        sql += " WHERE #{conditions.join(' AND ')}" unless conditions.empty?
+        sql += " ORDER BY se.scheduled_at ASC, se.priority ASC LIMIT #{limit.to_i}"
+
+        conn.select_all(sql).map do |row|
+          Job.new(
+            id: row["id"].to_i,
+            queue_name: row["queue_name"],
+            class_name: row["class_name"],
+            priority: row["priority"].to_i,
+            status: "scheduled",
+            active_job_id: row["active_job_id"],
+            arguments: parse_json(row["arguments"]),
+            scheduled_at: parse_time(row["scheduled_at"]),
+            created_at: parse_time(row["created_at"])
+          )
+        end
+      end
+
+      # Finished: query from jobs WHERE finished_at IS NOT NULL
+      def self.fetch_finished(filter: nil, queue: nil, limit: 200)
+        conn = ActiveRecord::Base.connection
+
+        sql = <<~SQL
+          SELECT
+            j.id, j.queue_name, j.class_name, j.priority,
+            j.active_job_id, j.arguments, j.finished_at, j.created_at
+          FROM solid_queue_jobs j
+          WHERE j.finished_at IS NOT NULL
+        SQL
+
+        sql += " AND j.queue_name = #{conn.quote(queue)}" if queue
+        sql += " AND j.class_name LIKE #{conn.quote("%#{filter}%")}" if filter && !filter.empty?
+        sql += " ORDER BY j.finished_at DESC LIMIT #{limit.to_i}"
+
+        conn.select_all(sql).map do |row|
+          Job.new(
+            id: row["id"].to_i,
+            queue_name: row["queue_name"],
+            class_name: row["class_name"],
+            priority: row["priority"].to_i,
+            status: "completed",
+            active_job_id: row["active_job_id"],
+            arguments: parse_json(row["arguments"]),
+            finished_at: parse_time(row["finished_at"]),
+            created_at: parse_time(row["created_at"])
+          )
+        end
+      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
+
+      private_class_method def self.parse_json(value)
+        return nil if value.nil?
+        value.is_a?(String) ? JSON.parse(value) : value
+      rescue
+        nil
+      end
+    end
+  end
+end

data/lib/solid_queue_tui/data/processes_query.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Data
+    class ProcessesQuery
+      Process = Struct.new(
+        :id, :kind, :pid, :hostname, :name, :last_heartbeat_at,
+        :supervisor_id, :metadata, :created_at,
+        keyword_init: true
+      ) do
+        def alive?(threshold: 60)
+          return false unless last_heartbeat_at
+          (Time.now.utc - last_heartbeat_at) < threshold
+        end
+
+        def uptime
+          return nil unless created_at
+          Time.now.utc - created_at
+        end
+
+        def queues
+          return [] unless metadata.is_a?(Hash)
+          metadata["queues"] || []
+        end
+
+        def thread_count
+          return nil unless metadata.is_a?(Hash)
+          metadata["threads"] || metadata["polling_interval"]
+        end
+      end
+
+      def self.fetch
+        conn = ActiveRecord::Base.connection
+
+        rows = conn.select_all(
+          "SELECT id, kind, pid, hostname, name, last_heartbeat_at, " \
+          "supervisor_id, metadata, created_at " \
+          "FROM solid_queue_processes WHERE kind = 'Worker' ORDER BY id"
+        )
+
+        rows.map do |row|
+          metadata = parse_json(row["metadata"])
+
+          Process.new(
+            id: row["id"].to_i,
+            kind: row["kind"],
+            pid: row["pid"].to_i,
+            hostname: row["hostname"],
+            name: row["name"],
+            last_heartbeat_at: parse_time(row["last_heartbeat_at"]),
+            supervisor_id: row["supervisor_id"]&.to_i,
+            metadata: metadata,
+            created_at: parse_time(row["created_at"])
+          )
+        end
+      rescue => e
+        []
+      end
+
+      private_class_method def self.parse_json(value)
+        return {} if value.nil?
+        value.is_a?(Hash) ? 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

data/lib/solid_queue_tui/data/queues_query.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Data
+    class QueuesQuery
+      QueueInfo = Struct.new(
+        :name, :size, :paused,
+        keyword_init: true
+      )
+
+      def self.fetch
+        conn = ActiveRecord::Base.connection
+
+        queue_sizes = conn.select_rows(
+          "SELECT queue_name, COUNT(*) FROM solid_queue_ready_executions GROUP BY queue_name ORDER BY queue_name"
+        ).to_h { |name, count| [name, count.to_i] }
+
+        all_queues = conn.select_values(
+          "SELECT DISTINCT queue_name FROM solid_queue_jobs WHERE queue_name IS NOT NULL ORDER BY queue_name"
+        )
+
+        paused = conn.select_values("SELECT queue_name FROM solid_queue_pauses")
+
+        all_queues.map do |name|
+          QueueInfo.new(
+            name: name,
+            size: queue_sizes[name] || 0,
+            paused: paused.include?(name)
+          )
+        end
+      rescue => e
+        []
+      end
+    end
+  end
+end

data/lib/solid_queue_tui/data/stats.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Data
+    class Stats
+      attr_reader :ready, :claimed, :failed, :scheduled, :blocked,
+                  :total_jobs, :completed_jobs, :process_count,
+                  :processes_by_kind
+
+      def initialize(data)
+        @ready = data[:ready]
+        @claimed = data[:claimed]
+        @failed = data[:failed]
+        @scheduled = data[:scheduled]
+        @blocked = data[:blocked]
+        @total_jobs = data[:total_jobs]
+        @completed_jobs = data[:completed_jobs]
+        @process_count = data[:process_count]
+        @processes_by_kind = data[:processes_by_kind]
+      end
+
+      def self.fetch
+        conn = ActiveRecord::Base.connection
+
+        new(
+          ready: count_table(conn, "solid_queue_ready_executions"),
+          claimed: count_table(conn, "solid_queue_claimed_executions"),
+          failed: count_table(conn, "solid_queue_failed_executions"),
+          scheduled: count_table(conn, "solid_queue_scheduled_executions"),
+          blocked: count_table(conn, "solid_queue_blocked_executions"),
+          total_jobs: count_table(conn, "solid_queue_jobs"),
+          completed_jobs: count_where(conn, "solid_queue_jobs", "finished_at IS NOT NULL"),
+          process_count: count_table(conn, "solid_queue_processes"),
+          processes_by_kind: processes_by_kind(conn)
+        )
+      rescue => e
+        empty(error: e.message)
+      end
+
+      def self.empty(error: nil)
+        new(
+          ready: 0, claimed: 0, failed: 0, scheduled: 0, blocked: 0,
+          total_jobs: 0, completed_jobs: 0, process_count: 0,
+          processes_by_kind: {}
+        )
+      end
+
+      private_class_method def self.count_table(conn, table)
+        conn.select_value("SELECT COUNT(*) FROM #{table}").to_i
+      end
+
+      private_class_method def self.count_where(conn, table, condition)
+        conn.select_value("SELECT COUNT(*) FROM #{table} WHERE #{condition}").to_i
+      end
+
+      private_class_method def self.processes_by_kind(conn)
+        rows = conn.select_rows(
+          "SELECT kind, COUNT(*) FROM solid_queue_processes GROUP BY kind"
+        )
+        rows.to_h { |kind, count| [kind, count.to_i] }
+      end
+
+    end
+  end
+end

data/lib/solid_queue_tui/dev_reloader.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  # Watches source files for changes and hot-reloads them using Kernel#load.
+  # Only active when initialized — zero overhead in production.
+  class DevReloader
+    def initialize(watch_dir)
+      @watch_dir = watch_dir
+      @file_mtimes = {}
+      snapshot_all!
+    end
+
+    # Returns true if any files changed and were reloaded.
+    def check!
+      changed = false
+
+      ruby_files.each do |path|
+        mtime = File.mtime(path)
+        if @file_mtimes[path] != mtime
+          @file_mtimes[path] = mtime
+          begin
+            suppress_warnings { load(path) }
+            changed = true
+          rescue SyntaxError, StandardError => e
+            # Don't crash the TUI on a syntax error mid-edit.
+            # The old code stays loaded — user just fixes and saves again.
+            $stderr.puts "[reload] Error loading #{File.basename(path)}: #{e.message}" if ENV["DEBUG"]
+          end
+        end
+      end
+
+      changed
+    end
+
+    private
+
+    def snapshot_all!
+      ruby_files.each { |path| @file_mtimes[path] = File.mtime(path) }
+    end
+
+    def ruby_files
+      Dir.glob(File.join(@watch_dir, "**", "*.rb"))
+    end
+
+    def suppress_warnings
+      old_verbose = $VERBOSE
+      $VERBOSE = nil
+      yield
+    ensure
+      $VERBOSE = old_verbose
+    end
+  end
+end

data/lib/solid_queue_tui/version.rb

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

data/lib/solid_queue_tui/views/blocked_view.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module SolidQueueTui
+  module Views
+    class BlockedView
+      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: :concurrency_key, label: "CONCURRENCY KEY",  width: :fill },
+          { key: :expires_at,      label: "EXPIRES AT",       width: 20 },
+          { key: :blocked_since,   label: "BLOCKED SINCE",    width: 14 }
+        ]
+
+        rows = @jobs.map do |job|
+          {
+            id: job.id,
+            queue_name: job.queue_name,
+            class_name: job.class_name,
+            priority: job.priority,
+            concurrency_key: job.concurrency_key || "n/a",
+            expires_at: format_time(job.expires_at),
+            blocked_since: time_ago(job.created_at)
+          }
+        end
+
+        table = Components::JobTable.new(
+          @tui,
+          title: "Blocked",
+          columns: columns,
+          rows: rows,
+          selected_row: @selected_row,
+          empty_message: "No blocked jobs"
+        )
+
+        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 = "blocked"
+
+      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 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