sqdash 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c6331093df3973dab4ab641090a1065e284147718c0475f104f831553b6ce106
+  data.tar.gz: 974aada0730279565ca8c7f24d9bc79d644052c960af4fe98725d0b771e9f9a3
+SHA512:
+  metadata.gz: 85d9f93d466ef2731a851c34375a6675b9e94a965752614a730825593f2641168e3cf522b2ca82338b235a7346b9e5df88391866fef1598c5892e1eb67a553ce
+  data.tar.gz: bfe3cfe773ea0cca2aa708ffd87c216012d93985d91eaef90784be752e5d529b5d5a52f3ede55d4dc818a905da54e7b1c34acc138009b32db3ff1d631ae8d584

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Nuha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,110 @@
+# sqdash
+
+A terminal dashboard for Rails 8's Solid Queue.
+
+Solid Queue is the default Active Job backend in Rails 8, but it ships with no built-in UI. sqdash gives you a fast, keyboard-driven TUI to monitor and manage jobs without leaving your terminal — no browser, no extra server, no mounted routes.
+
+## Features
+
+- Live overview of all Solid Queue jobs with status, queue, and timestamps
+- View filters: all, failed, completed, pending
+- Sortable by created date or ID, ascending or descending
+- Fuzzy text filter across job class, queue name, and ID
+- Retry or discard failed jobs with a single keypress
+- k9s-style `:` command bar with Tab autocomplete
+- `/` search with inline autocomplete hints
+
+## Installation
+
+```bash
+gem install sqdash
+```
+
+Or add it to your Gemfile:
+
+```bash
+bundle add sqdash
+```
+
+## Prerequisites
+
+sqdash connects directly to your Solid Queue database. You need:
+
+- A database with the Solid Queue schema (`solid_queue_*` tables) — PostgreSQL, MySQL, or SQLite
+- Ruby >= 3.0
+- The database adapter gem for your database:
+
+```bash
+gem install pg       # PostgreSQL
+gem install mysql2   # MySQL
+gem install sqlite3  # SQLite
+```
+
+## Usage
+
+```bash
+# PostgreSQL
+sqdash postgres://user:pass@localhost:5432/myapp_queue
+
+# MySQL
+sqdash mysql2://user:pass@localhost:3306/myapp_queue
+
+# SQLite
+sqdash sqlite3:///path/to/queue.db
+
+# Or set the DATABASE_URL environment variable
+export DATABASE_URL=postgres://user:pass@localhost:5432/myapp_queue
+sqdash
+
+# Falls back to default: postgres://sqd:sqd@localhost:5432/sqd_web_development_queue
+sqdash
+```
+
+Connection priority: **CLI argument** > **`DATABASE_URL` env var** > **built-in default**.
+
+### Keyboard shortcuts
+
+| Key | Action |
+|-----|--------|
+| `↑` `↓` | Navigate job list |
+| `/` | Filter jobs (fuzzy search across all columns) |
+| `:` | Command bar (sort, switch views) |
+| `Tab` | Autocomplete (in filter or command mode) |
+| `r` | Retry selected failed job |
+| `d` | Discard selected failed job |
+| `Space` | Refresh data |
+| `q` | Quit |
+
+### Commands
+
+Type `:` to open the command bar, then:
+
+| Command | Description |
+|---------|-------------|
+| `sort created desc` | Sort by created date, newest first (default) |
+| `sort created asc` | Sort by created date, oldest first |
+| `sort id desc` | Sort by job ID, highest first |
+| `sort id asc` | Sort by job ID, lowest first |
+| `view all` | Show all jobs |
+| `view failed` | Show only failed jobs |
+| `view completed` | Show only completed jobs |
+| `view pending` | Show only pending jobs |
+
+Arguments are optional — `sort` defaults to `sort created desc`, `view` defaults to `view all`.
+
+## Development
+
+```bash
+git clone https://github.com/nuhasami/sqdash.git
+cd sqdash
+bin/setup
+bundle exec ruby exe/sqdash
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/nuhasami/sqdash.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/exe/sqdash

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require "sqdash"
+Sqdash::CLI.start

data/lib/sqdash/cli.rb

@@ -0,0 +1,760 @@
+# frozen_string_literal: true
+
+require "io/console"
+require "json"
+
+module Sqdash
+  class CLI
+    DEFAULT_DB_URL = "postgres://sqd:sqd@localhost:5432/sqd_web_development_queue"
+
+    COMMANDS = {
+      "sort" => {
+        "created" => ["asc", "desc"],
+        "id" => ["asc", "desc"]
+      },
+      "view" => {
+        "all" => [],
+        "failed" => [],
+        "completed" => [],
+        "pending" => []
+      }
+    }.freeze
+
+    def self.start
+      new.run
+    end
+
+    def run
+      Database.connect!(resolve_db_url)
+      @selected = 0
+      @scroll_offset = 0
+      @filter_text = ""
+      @filter_mode = false
+      @view = :all  # :all, :failed, :completed, :pending
+      @jobs = []
+      @failed_ids = []
+      @message = nil
+      @sort_column = :created_at
+      @sort_dir = :desc
+      @command_mode = false
+      @command_text = ""
+      @detail_job = nil
+      @detail_scroll = 0
+      trap_resize
+      load_data
+      full_draw
+      catch(:quit) { handle_input }
+    ensure
+      Signal.trap("WINCH", "DEFAULT")
+      cleanup
+    end
+
+    private
+
+    def resolve_db_url
+      ARGV[0] || ENV["DATABASE_URL"] || DEFAULT_DB_URL
+    end
+
+    def cleanup
+      print "\e[?25h"
+      print "\e[2J\e[H"
+      puts "Goodbye!"
+    end
+
+    def trap_resize
+      Signal.trap("WINCH") do
+        @needs_redraw = true
+      end
+    end
+
+    def truncate(str, max)
+      return str if str.length <= max
+
+      # Strip ANSI codes to measure visible length
+      visible = str.gsub(/\e\[[0-9;]*m/, "")
+      return str if visible.length <= max
+
+      # Truncate by walking through the string, tracking visible chars
+      result = +""
+      visible_count = 0
+      i = 0
+      while i < str.length && visible_count < max
+        if str[i] == "\e" && str[i..] =~ /\A(\e\[[0-9;]*m)/
+          result << $1
+          i += $1.length
+        else
+          result << str[i]
+          visible_count += 1
+          i += 1
+        end
+      end
+      result << "\e[0m"
+    end
+
+    def terminal_height
+      $stdout.winsize[0]
+    end
+
+    def terminal_width
+      $stdout.winsize[1]
+    end
+
+    def visible_rows
+      [terminal_height - 11, 5].max
+    end
+
+    def load_data
+      @failed_ids = Models::FailedExecution.pluck(:job_id)
+
+      scope = Models::Job.order(@sort_column => @sort_dir)
+
+      # View filter
+      case @view
+      when :failed
+        scope = @failed_ids.any? ? scope.where(id: @failed_ids) : scope.none
+      when :completed
+        scope = scope.where.not(finished_at: nil).where.not(id: @failed_ids)
+      when :pending
+        scope = scope.where(finished_at: nil).where.not(id: @failed_ids)
+      end
+
+      @jobs = scope.to_a
+
+      # Text filter (k9s style — filters across all visible columns)
+      if @filter_text.length > 0
+        query = @filter_text.downcase
+        @jobs = @jobs.select do |job|
+          job.class_name.downcase.include?(query) ||
+            job.queue_name.downcase.include?(query) ||
+            job.id.to_s.include?(query)
+        end
+      end
+
+      # Clamp selection
+      @selected = [[@selected, @jobs.length - 1].min, 0].max
+      adjust_scroll
+    end
+
+    def adjust_scroll
+      if @selected < @scroll_offset
+        @scroll_offset = @selected
+      elsif @selected >= @scroll_offset + visible_rows
+        @scroll_offset = @selected - visible_rows + 1
+      end
+    end
+
+    def job_status(job)
+      if @failed_ids.include?(job.id)
+        :failed
+      elsif job.finished_at
+        :completed
+      else
+        :pending
+      end
+    end
+
+    def status_text(status)
+      case status
+      when :failed    then "\e[31m● failed\e[0m   "
+      when :completed then "\e[32m● completed\e[0m"
+      when :pending   then "\e[33m● pending\e[0m  "
+      end
+    end
+
+    def view_label
+      case @view
+      when :all       then "ALL"
+      when :failed    then "\e[31mFAILED\e[0m"
+      when :completed then "\e[32mCOMPLETED\e[0m"
+      when :pending   then "\e[33mPENDING\e[0m"
+      end
+    end
+
+    def full_draw
+      print "\e[?25l"
+      print "\e[2J\e[H"
+      draw_screen
+    end
+
+    def column_widths
+      w = terminal_width
+      # Fixed columns: prefix(2) + ID(8) + Status(14) + Created(12) = 36
+      remaining = [w - 36, 10].max
+      # Job gets 65% of remaining, Queue gets 35%
+      job_w = [remaining * 65 / 100, 6].max
+      queue_w = [remaining - job_w, 4].max
+      { id: 8, job: job_w, queue: queue_w, status: 14, created: 12 }
+    end
+
+    def draw_screen
+      if @detail_job
+        draw_detail_screen
+      else
+        draw_list_screen
+      end
+    end
+
+    def draw_list_screen
+      print "\e[H" # cursor home, no clear
+      w = terminal_width
+      rows = visible_rows
+      cols = column_widths
+
+      # Header
+      puts truncate("\e[1;36m sqdash \e[0m\e[36m Solid Queue Dashboard v#{Sqdash::VERSION}\e[0m", w) + "\e[K"
+      puts "\e[90m#{"─" * w}\e[0m"
+
+      # Stats bar
+      total = Models::Job.count
+      completed = Models::Job.where.not(finished_at: nil).count
+      failed = @failed_ids.length
+      pending = Models::ReadyExecution.count
+      sort_label = "#{@sort_column == :id ? "ID" : "Created"} #{@sort_dir == :asc ? "↑" : "↓"}"
+      stats = " \e[1mTotal:\e[0m #{total}  \e[32m✓ #{completed}\e[0m  \e[31m✗ #{failed}\e[0m  \e[33m◌ #{pending}\e[0m  │  View: #{view_label}  │  Sort: #{sort_label}  │  Showing: #{@jobs.length}"
+      puts truncate(stats, w) + "\e[K"
+
+      # Filter / Command bar
+      if @command_mode
+        print "\e[?25h"
+        hint = command_autocomplete_hint
+        puts truncate(" \e[1;35m:\e[0m #{@command_text}\e[90m#{hint}\e[0m  \e[90m<Tab> complete  <Enter> run  <Esc> cancel\e[0m", w) + "\e[K"
+      elsif @filter_mode
+        print "\e[?25h" # show cursor in filter mode
+        hint = autocomplete_hint
+        puts truncate(" \e[1;33m/\e[0m #{@filter_text}\e[90m#{hint}\e[0m  \e[90m<Tab> complete  <Esc> cancel\e[0m", w) + "\e[K"
+      elsif @filter_text.length > 0
+        puts truncate(" \e[33m/#{@filter_text}\e[0m  \e[90m(/ to edit, Esc to clear)\e[0m", w) + "\e[K"
+      else
+        puts "\e[K"
+      end
+
+      puts "\e[90m#{"─" * w}\e[0m"
+
+      # Column headers
+      puts truncate("\e[1m  #{"ID".ljust(cols[:id])}#{"Job".ljust(cols[:job])}#{"Queue".ljust(cols[:queue])}#{"Status".ljust(cols[:status])}Created\e[0m", w) + "\e[K"
+
+      # Job list
+      visible_jobs = @jobs[@scroll_offset, rows] || []
+
+      visible_jobs.each_with_index do |job, i|
+        actual_index = @scroll_offset + i
+        status = job_status(job)
+        is_selected = actual_index == @selected
+        created = job.created_at&.strftime("%m/%d %H:%M") || "—"
+
+        line = "#{job.id.to_s.ljust(cols[:id])}#{job.class_name[0, cols[:job] - 1].ljust(cols[:job])}#{job.queue_name[0, cols[:queue] - 1].ljust(cols[:queue])}#{status_text(status)}  #{created}"
+
+        if is_selected
+          puts truncate("\e[7m▸ #{line}\e[0m", w) + "\e[K"
+        else
+          puts truncate("  #{line}", w) + "\e[K"
+        end
+      end
+
+      # Clear remaining rows
+      (rows - visible_jobs.length).times { puts "\e[K" }
+
+      # Scrollbar hint
+      puts "\e[90m#{"─" * w}\e[0m"
+
+      # Message or footer
+      if @message
+        puts " \e[1;32m#{@message}\e[0m\e[K"
+        @message = nil
+      else
+        puts truncate(" \e[90m↑↓ Navigate  Enter Detail  /Filter  :Command  r Retry  d Discard  q Quit\e[0m", w) + "\e[K"
+      end
+
+      # Position info
+      if @jobs.length > 0
+        pos = "#{@selected + 1}/#{@jobs.length}"
+        print "\e[#{terminal_height};#{w - pos.length}H\e[90m#{pos}\e[0m"
+      end
+    end
+
+    def handle_input
+      @saved_stty = `stty -g`.chomp
+      system("stty", "-echo", "-icanon", "min", "1")
+      loop do
+        if @needs_redraw
+          @needs_redraw = false
+          adjust_scroll
+          full_draw
+        end
+
+        key = read_key
+
+        unless key
+          # No input — auto-refresh data on idle
+          if @detail_job
+            @detail_job.reload
+          else
+            load_data
+          end
+          draw_screen
+          next
+        end
+
+        if @detail_job
+          handle_detail_input(key)
+        elsif @command_mode
+          handle_command_input(key)
+        elsif @filter_mode
+          handle_filter_input(key)
+        else
+          handle_normal_input(key)
+        end
+
+        draw_screen
+      end
+    ensure
+      system("stty", @saved_stty) if @saved_stty
+    end
+
+    def read_key
+      ready = IO.select([$stdin], nil, nil, 1)
+      return nil unless ready
+
+      $stdin.getc
+    end
+
+    def handle_filter_input(key)
+      case key
+      when "\r", "\n" # Enter — confirm filter
+        @filter_mode = false
+        print "\e[?25l"
+        load_data
+      when "\e" # Escape — cancel filter (drain arrow key bytes)
+        $stdin.read_nonblock(2) rescue nil
+        @filter_mode = false
+        @filter_text = ""
+        print "\e[?25l"
+        load_data
+      when "\t" # Tab — autocomplete
+        autocomplete_filter
+      when "\u007F", "\b" # Backspace
+        @filter_text = @filter_text[0..-2]
+        load_data
+      else
+        if key.match?(/[[:print:]]/)
+          @filter_text += key
+          load_data
+        end
+      end
+    end
+
+    def autocomplete_filter
+      return if @filter_text.empty?
+
+      query = @filter_text.downcase
+
+      # Collect all completable values
+      candidates = (
+        Models::Job.distinct.pluck(:class_name) +
+        Models::Job.distinct.pluck(:queue_name)
+      ).uniq
+
+      matches = candidates.select { |c| c.downcase.start_with?(query) }
+
+      if matches.length == 1
+        # Exact single match — complete it
+        @filter_text = matches.first
+      elsif matches.length > 1
+        # Multiple matches — complete to common prefix
+        @filter_text = common_prefix(matches)
+      end
+
+      load_data
+    end
+
+    def autocomplete_hint
+      return "" if @filter_text.empty?
+
+      query = @filter_text.downcase
+      candidates = (
+        Models::Job.distinct.pluck(:class_name) +
+        Models::Job.distinct.pluck(:queue_name)
+      ).uniq
+
+      matches = candidates.select { |c| c.downcase.start_with?(query) }
+
+      if matches.length == 1
+        matches.first[@filter_text.length..]
+      elsif matches.length > 1
+        prefix = common_prefix(matches)
+        remaining = prefix[@filter_text.length..] || ""
+        remaining + " (#{matches.length} matches)"
+      else
+        " (no matches)"
+      end
+    end
+
+    def common_prefix(strings)
+      return "" if strings.empty?
+
+      prefix = strings.first
+      strings.each do |s|
+        prefix = prefix[0...prefix.length].chars.take_while.with_index { |c, i| s[i]&.downcase == c.downcase }.join
+      end
+      prefix
+    end
+
+    def handle_normal_input(key)
+      case key
+      when "\e"
+        next_chars = $stdin.read_nonblock(2) rescue nil
+        case next_chars
+        when "[A" # up
+          @selected = [0, @selected - 1].max
+          adjust_scroll
+        when "[B" # down
+          @selected = [@jobs.length - 1, @selected + 1].min
+          adjust_scroll
+        when nil # bare Escape — clear active filter
+          if @filter_text.length > 0
+            @filter_text = ""
+            load_data
+          end
+        end
+      when "q"
+        throw(:quit)
+      when "/"
+        @filter_mode = true
+        @filter_text = ""
+      when ":"
+        @command_mode = true
+        @command_text = ""
+      when "r"
+        retry_selected
+      when "d"
+        discard_selected
+      when "\r", "\n"
+        show_detail
+      when " "
+        load_data
+      end
+    end
+
+    def switch_view(view)
+      @view = view
+      @selected = 0
+      @scroll_offset = 0
+      load_data
+    end
+
+    def handle_command_input(key)
+      case key
+      when "\r", "\n" # Enter — execute command
+        execute_command
+        @command_mode = false
+        @command_text = ""
+        print "\e[?25l"
+      when "\e" # Escape — cancel (drain arrow key bytes)
+        $stdin.read_nonblock(2) rescue nil
+        @command_mode = false
+        @command_text = ""
+        print "\e[?25l"
+      when "\t" # Tab — autocomplete
+        autocomplete_command
+      when "\u007F", "\b" # Backspace
+        @command_text = @command_text[0..-2]
+      else
+        if key.match?(/[[:print:]]/)
+          @command_text += key
+        end
+      end
+    end
+
+    def execute_command
+      parts = @command_text.strip.split(/\s+/)
+      return if parts.empty?
+
+      case parts[0]
+      when "sort"
+        field = parts[1] || "created"
+        direction = parts[2] || "desc"
+        case field
+        when "created"
+          @sort_column = :created_at
+        when "id"
+          @sort_column = :id
+        else
+          @message = "Unknown sort field: #{field}"
+          return
+        end
+        case direction
+        when "asc"  then @sort_dir = :asc
+        when "desc" then @sort_dir = :desc
+        else
+          @message = "Unknown sort direction: #{direction}"
+          return
+        end
+        @selected = 0
+        @scroll_offset = 0
+        load_data
+      when "view"
+        target = parts[1] || "all"
+        case target
+        when "all"       then switch_view(:all)
+        when "failed"    then switch_view(:failed)
+        when "completed" then switch_view(:completed)
+        when "pending"   then switch_view(:pending)
+        else
+          @message = "Unknown view: #{target}"
+        end
+      else
+        @message = "Unknown command: #{parts[0]}"
+      end
+    end
+
+    def autocomplete_command
+      return if @command_text.empty?
+
+      parts = @command_text.strip.split(/\s+/)
+      # If text ends with space, we're starting a new word
+      completing_new_word = @command_text.end_with?(" ")
+
+      if completing_new_word
+        case parts.length
+        when 1
+          # After first word + space, complete second word
+          subtree = COMMANDS[parts[0]]
+          return unless subtree.is_a?(Hash)
+          completed = complete_word("", subtree.keys)
+          @command_text = "#{parts[0]} #{completed}" if completed
+        when 2
+          # After second word + space, complete third word
+          subtree = COMMANDS.dig(parts[0], parts[1])
+          return unless subtree.is_a?(Array) && subtree.any?
+          completed = complete_word("", subtree)
+          @command_text = "#{parts[0]} #{parts[1]} #{completed}" if completed
+        end
+      else
+        case parts.length
+        when 1
+          completed = complete_word(parts[0], COMMANDS.keys)
+          @command_text = completed if completed
+        when 2
+          subtree = COMMANDS[parts[0]]
+          return unless subtree.is_a?(Hash)
+          completed = complete_word(parts[1], subtree.keys)
+          @command_text = "#{parts[0]} #{completed}" if completed
+        when 3
+          subtree = COMMANDS.dig(parts[0], parts[1])
+          return unless subtree.is_a?(Array) && subtree.any?
+          completed = complete_word(parts[2], subtree)
+          @command_text = "#{parts[0]} #{parts[1]} #{completed}" if completed
+        end
+      end
+    end
+
+    def complete_word(partial, candidates)
+      matches = candidates.select { |c| c.downcase.start_with?(partial.downcase) }
+      if matches.length == 1
+        matches.first
+      elsif matches.length > 1
+        prefix = common_prefix(matches)
+        # Only return if the prefix actually advances beyond what's typed
+        prefix.length > partial.length ? prefix : nil
+      end
+    end
+
+    def command_autocomplete_hint
+      return "" if @command_text.empty?
+
+      parts = @command_text.strip.split(/\s+/)
+      completing_new_word = @command_text.end_with?(" ")
+
+      if completing_new_word
+        case parts.length
+        when 1
+          subtree = COMMANDS[parts[0]]
+          return "" unless subtree.is_a?(Hash)
+          hint_for_candidates("", subtree.keys)
+        when 2
+          subtree = COMMANDS.dig(parts[0], parts[1])
+          return "" unless subtree.is_a?(Array) && subtree.any?
+          hint_for_candidates("", subtree)
+        else
+          ""
+        end
+      else
+        case parts.length
+        when 1
+          hint_for_candidates(parts[0], COMMANDS.keys)
+        when 2
+          subtree = COMMANDS[parts[0]]
+          return "" unless subtree.is_a?(Hash)
+          hint_for_candidates(parts[1], subtree.keys)
+        when 3
+          subtree = COMMANDS.dig(parts[0], parts[1])
+          return "" unless subtree.is_a?(Array) && subtree.any?
+          hint_for_candidates(parts[2], subtree)
+        else
+          ""
+        end
+      end
+    end
+
+    def hint_for_candidates(partial, candidates)
+      matches = candidates.select { |c| c.downcase.start_with?(partial.downcase) }
+      if matches.length == 1
+        matches.first[partial.length..]
+      elsif matches.length > 1
+        prefix = common_prefix(matches)
+        remaining = prefix[partial.length..] || ""
+        remaining + " (#{matches.map { |m| m }.join("|")})"
+      else
+        " (no matches)"
+      end
+    end
+
+    def show_detail
+      return if @jobs.empty?
+      @detail_job = @jobs[@selected]
+      @detail_scroll = 0
+      full_draw
+    end
+
+    def build_detail_lines(job)
+      lines = []
+
+      lines << "\e[1mClass:\e[0m       #{job.class_name}"
+      lines << "\e[1mQueue:\e[0m       #{job.queue_name}"
+      lines << "\e[1mPriority:\e[0m    #{job.priority || "—"}"
+      lines << "\e[1mActive Job:\e[0m  #{job.active_job_id || "—"}"
+      lines << ""
+
+      status = job_status(job)
+      lines << "\e[1mStatus:\e[0m      #{status_text(status)}"
+      lines << ""
+
+      lines << "\e[1mCreated:\e[0m     #{job.created_at || "—"}"
+      lines << "\e[1mScheduled:\e[0m   #{job.scheduled_at || "—"}"
+      lines << "\e[1mFinished:\e[0m    #{job.finished_at || "—"}"
+      lines << ""
+
+      lines << "\e[1mArguments:\e[0m"
+      begin
+        args = JSON.parse(job.arguments)
+        JSON.pretty_generate(args).each_line { |l| lines << "  #{l.chomp}" }
+      rescue JSON::ParserError
+        lines << "  #{job.arguments}"
+      end
+
+      if status == :failed && job.failed_execution
+        lines << ""
+        lines << "\e[1;31mError:\e[0m"
+        error_text = job.failed_execution.error || "No error message"
+        error_text.each_line { |l| lines << "  #{l.chomp}" }
+      end
+
+      lines
+    end
+
+    def draw_detail_screen
+      print "\e[H"
+      w = terminal_width
+      rows = terminal_height
+
+      # Header
+      puts truncate("\e[1;36m sqdash \e[0m\e[36m Job ##{@detail_job.id}\e[0m", w) + "\e[K"
+      puts "\e[90m#{"─" * w}\e[0m"
+
+      # Content area: rows - 4 (header, separator, separator, footer)
+      content_rows = rows - 4
+      lines = build_detail_lines(@detail_job)
+
+      # Clamp scroll
+      max_scroll = [lines.length - content_rows, 0].max
+      @detail_scroll = [[@detail_scroll, max_scroll].min, 0].max
+
+      visible = lines[@detail_scroll, content_rows] || []
+      visible.each { |line| puts truncate("  #{line}", w) + "\e[K" }
+
+      # Clear remaining rows
+      (content_rows - visible.length).times { puts "\e[K" }
+
+      puts "\e[90m#{"─" * w}\e[0m"
+
+      if @message
+        puts " \e[1;32m#{@message}\e[0m\e[K"
+        @message = nil
+      else
+        puts truncate(" \e[90mEsc Back  ↑↓ Scroll  r Retry  d Discard  q Quit\e[0m", w) + "\e[K"
+      end
+    end
+
+    def handle_detail_input(key)
+      case key
+      when "\e"
+        next_chars = $stdin.read_nonblock(2) rescue nil
+        case next_chars
+        when "[A" # up
+          @detail_scroll = [@detail_scroll - 1, 0].max
+        when "[B" # down
+          @detail_scroll += 1
+        when nil # bare Escape — back to list
+          @detail_job = nil
+          full_draw
+        end
+      when "\u007F", "\b" # Backspace — back to list
+        @detail_job = nil
+        full_draw
+      when "r"
+        failed = Models::FailedExecution.find_by(job_id: @detail_job.id)
+        if failed
+          failed.retry!
+          @message = "Retried job #{@detail_job.id} (#{@detail_job.class_name})"
+          @detail_job.reload
+          load_data
+        else
+          @message = "Job #{@detail_job.id} is not failed"
+        end
+      when "d"
+        failed = Models::FailedExecution.find_by(job_id: @detail_job.id)
+        if failed
+          failed.discard!
+          @message = "Discarded job #{@detail_job.id} (#{@detail_job.class_name})"
+          @detail_job = nil
+          load_data
+          full_draw
+        else
+          @message = "Job #{@detail_job.id} is not failed"
+        end
+      when "q"
+        throw(:quit)
+      end
+    end
+
+    def retry_selected
+      job = @jobs[@selected]
+      return unless job
+
+      failed = Models::FailedExecution.find_by(job_id: job.id)
+      unless failed
+        @message = "Job #{job.id} is not failed"
+        return
+      end
+
+      failed.retry!
+      @message = "Retried job #{job.id} (#{job.class_name})"
+      load_data
+    end
+
+    def discard_selected
+      job = @jobs[@selected]
+      return unless job
+
+      failed = Models::FailedExecution.find_by(job_id: job.id)
+      unless failed
+        @message = "Job #{job.id} is not failed"
+        return
+      end
+
+      failed.discard!
+      @message = "Discarded job #{job.id} (#{job.class_name})"
+      load_data
+    end
+  end
+end

data/lib/sqdash/database.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module Sqdash
+  class Database
+    ADAPTERS = {
+      "postgres" => { gem: "pg", adapter: "postgresql" },
+      "postgresql" => { gem: "pg", adapter: "postgresql" },
+      "mysql2" => { gem: "mysql2", adapter: "mysql2" },
+      "sqlite3" => { gem: "sqlite3", adapter: "sqlite3" }
+    }.freeze
+
+    def self.connect!(url)
+      require_adapter!(url)
+      ActiveRecord::Base.establish_connection(url)
+      ActiveRecord::Base.connection
+    rescue ActiveRecord::ConnectionNotEstablished => e
+      abort "\e[31mFailed to connect to database: #{e.message}\e[0m"
+    end
+
+    def self.require_adapter!(url)
+      scheme = url.split("://").first.split(":").first
+      config = ADAPTERS[scheme]
+
+      unless config
+        abort "\e[31mUnsupported database adapter: #{scheme}\n" \
+              "Supported: postgres, mysql2, sqlite3\e[0m"
+      end
+
+      require config[:gem]
+    rescue LoadError
+      abort "\e[31mMissing database adapter gem '#{config[:gem]}'. Install it with:\n" \
+            "  gem install #{config[:gem]}\e[0m"
+    end
+  end
+end

data/lib/sqdash/models/failed_execution.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Sqdash
+  module Models
+    class FailedExecution < ActiveRecord::Base
+      self.table_name = "solid_queue_failed_executions"
+
+      belongs_to :job, class_name: "Sqdash::Models::Job"
+
+      def retry!
+        transaction do
+          ReadyExecution.create!(
+            job_id: job_id,
+            queue_name: job.queue_name,
+            priority: job.priority
+          )
+          destroy!
+        end
+      end
+
+      def discard!
+        transaction do
+          job.update!(finished_at: Time.now)
+          destroy!
+        end
+      end
+    end
+  end
+end

data/lib/sqdash/models/job.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Sqdash
+  module Models
+    class Job < ActiveRecord::Base
+      self.table_name = "solid_queue_jobs"
+
+      has_one :failed_execution, class_name: "Sqdash::Models::FailedExecution", foreign_key: :job_id
+      has_one :ready_execution, class_name: "Sqdash::Models::ReadyExecution", foreign_key: :job_id
+    end
+  end
+end

data/lib/sqdash/models/ready_execution.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Sqdash
+  module Models
+    class ReadyExecution < ActiveRecord::Base
+      self.table_name = "solid_queue_ready_executions"
+    end
+  end
+end

data/lib/sqdash/version.rb

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

data/lib/sqdash.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "sqdash/version"
+require_relative "sqdash/database"
+require_relative "sqdash/models/job"
+require_relative "sqdash/models/failed_execution"
+require_relative "sqdash/models/ready_execution"
+require_relative "sqdash/cli"
+
+module Sqdash
+  class Error < StandardError; end
+end

data/sig/sqdash.rbs

@@ -0,0 +1,4 @@
+module Sqdash
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: sqdash
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nuha
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-03-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+description: sqdash is a fast, keyboard-driven TUI for monitoring and managing Solid
+  Queue jobs. View pending, failed, and completed jobs, retry or discard failures,
+  filter, sort, and navigate — all without leaving your terminal.
+email:
+- nuha.sami@hey.com
+executables:
+- sqdash
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/sqdash
+- lib/sqdash.rb
+- lib/sqdash/cli.rb
+- lib/sqdash/database.rb
+- lib/sqdash/models/failed_execution.rb
+- lib/sqdash/models/job.rb
+- lib/sqdash/models/ready_execution.rb
+- lib/sqdash/version.rb
+- sig/sqdash.rbs
+homepage: https://github.com/nuhasami/sqdash
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/nuhasami/sqdash
+  source_code_uri: https://github.com/nuhasami/sqdash
+  changelog_uri: https://github.com/nuhasami/sqdash/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: A terminal dashboard for Rails 8's Solid Queue
+test_files: []