slk 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 895e4fdd405a7b4f560424a93d4906ea7330088763a5559b2d581788908794b3
-  data.tar.gz: 6f8c66d9cd6555153db454d99d7cafdf4e82bbaac2f6349edee1427047e31104
+  metadata.gz: ae44e63120d4264c9adeb4adb2ea9aba96c4fe9e6087c1134f9bd9d8480a843e
+  data.tar.gz: '087ea385b7cf62868737d1e583e60ec9fac5aee8bb3d49f711f5c979413db4e7'
 SHA512:
-  metadata.gz: 7394318fac53168225d5ff30a249612a0f756fe60eaca67141ca937d43f8c70aaa7a1066681bb35a97fc49f242254d87438f369b02700193cc86456ded97ca9c
-  data.tar.gz: ea890ffc51e6540c6a19db3481d92b8f0263c042594f74c4ec2ac3f975c7f988d345f69e0a6b37345993b499535180b87456cd189dffa9506b2c60148f2b9481
+  metadata.gz: 71be8f27208e35f5dfe81c3504f38f40af7a7630d93802ba56316e07778aa631f7a42ffe1172b9b1c280735871c0667b5b6568a3bb0224642cdabf59523ac8c5
+  data.tar.gz: 9e4b991d52004df5100fe901e87c1b61f8c50a8fa501665f2cb0a5f58f31a37a6ffae6cbe5c287aac7ae2e99f679cea0889c80866f7980b7f495c7311a507c73

data/CHANGELOG.md

@@ -5,6 +5,25 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.8.0] - 2026-08-30
+
+### Added
+
+- **`slk status` now answers the questions the status raises** — who can reach you, and whether the status is about to change on its own
+  - Presence and DND appear as suffixes on the status line: `:computer: Working [away] [dnd until 3:00pm]`. Only exceptional states are labelled, so the workspace that differs stands out rather than being buried under "active" on every line
+  - `[dnd until …]` covers a manual snooze and the configured DND hours alike — from the outside both mean messages do not notify — and reports the later end when both apply. `slk dnd` still breaks out which is which
+  - Anything scheduled to turn on later is listed under the status, soonest first and without IDs; `slk status scheduled` remains the view to paste an ID from
+  - Times carry a day when the end is not today, so an overnight window does not read as a time that has already passed
+- **`slk status --json`** (and `slk status scheduled --json`) for scripts and statuslines
+  - Always an array, one entry per workspace, even for a single workspace: a document whose shape changes with `-w` cannot be parsed by a script that did not pass it
+  - `null` means "not checked" — skipped by a flag, or a lookup that failed — as distinct from checked-and-empty. A statusline that read a failed DND lookup as "DND off" would report the opposite of the truth
+  - Every timestamp appears twice: Slack's own epoch under Slack's own field name, and an ISO 8601 string beside it
+- **`--brief` and `--no-scheduled`** for the get view. It now costs up to four calls per workspace; `--no-scheduled` drops the internal `users.customStatus.list` lookup and `--brief` drops all three extras. `--quiet` skips them too, since their output would be discarded (`--json` still gathers them: it prints regardless)
+
+### Changed
+
+- A failed presence, DND or schedule lookup during `slk status` warns and omits that part instead of failing the command — the status itself is what was asked for. A rate limit stops the remaining extra lookups altogether rather than spending calls the status reads need
+
 ## [0.7.0] - 2026-08-03
 
 ### Added
@@ -210,6 +229,7 @@ Initial release of the Ruby rewrite. Pure Ruby, no external dependencies.
   - Pure Ruby stdlib - no gem dependencies
   - Ruby 3.2+ with modern features (Data.define, pattern matching)
 
+[0.8.0]: https://github.com/ericboehs/slk/releases/tag/v0.8.0
 [0.7.0]: https://github.com/ericboehs/slk/releases/tag/v0.7.0
 [0.6.0]: https://github.com/ericboehs/slk/releases/tag/v0.6.0
 [0.5.0]: https://github.com/ericboehs/slk/releases/tag/v0.5.0

data/README.md

@@ -46,12 +46,52 @@ You'll need a Slack token. Get one from:
 ### Status
 
 ```bash
-slk status                              # Show current status
+slk status                              # Status, presence, DND and what's queued next
+slk status --brief                      # Status text only (one call per workspace)
+slk status --json                       # Machine-readable, for scripts and statuslines
 slk status "Working from home" :house:  # Set status with emoji
 slk status "In a meeting" :calendar: 1h # Set status for 1 hour
 slk status clear                        # Clear status
 ```
 
+Getting the status also answers the two questions it usually raises — can anyone
+reach me, and is this about to change on its own:
+
+```
+$ slk status
+work
+  :computer: Working [away] [dnd until 3:00pm]
+  Scheduled:
+    :paw_prints: Vet Appt (Mon Aug 3 1:30pm -> 3:30pm)
+side-project
+  (no status set)
+```
+
+Only the exceptional states are labelled: an active, notifiable workspace says
+nothing, so the one that differs stands out. `[dnd until ...]` covers both a
+manual snooze and the configured DND hours — from the outside they are the same
+thing — and `slk dnd` breaks out which.
+
+Each of those is a separate call, so `slk status` costs up to four per
+workspace. `--no-scheduled` drops the schedule lookup (the one internal
+endpoint), `--brief` drops all three, and a lookup that fails warns and leaves
+that part out rather than failing the command.
+
+#### JSON output
+
+`slk status --json` (and `slk status scheduled --json`) prints one entry per
+workspace — always an array, even for a single workspace, so a script that did
+not pass `-w` can still parse it. `null` means *not checked* (skipped by a flag,
+or the lookup failed), which is not the same as checked-and-empty: a statusline
+that read a failed DND lookup as "DND off" would say the opposite of the truth.
+Every timestamp appears twice, as Slack's epoch and as ISO 8601:
+
+```bash
+# "away, quiet until 3:00pm"
+slk status -w work --json --no-scheduled |
+  jq -r '.[0] | "\(.presence.presence)\(if .dnd.active then ", quiet until " + (.dnd.until | strflocaltime("%-I:%M%p")) else "" end)"'
+```
+
 Statuses can also be scheduled to turn on later (Slack allows up to 5 at a time):
 
 ```bash

data/lib/slk/commands/status.rb

@@ -38,24 +38,39 @@ module Slk
       protected
 
       def default_options
-        super.merge(presence: nil, dnd: nil, with_dnd: false, start_at: nil, end_at: nil)
+        super.merge(presence: nil, dnd: nil, with_dnd: false, start_at: nil, end_at: nil,
+                    scheduled: true, brief: false)
       end
 
+      # Flags that only flip a boolean live here rather than in the case below,
+      # which is already at the branch count the linter allows.
+      TOGGLES = { '--with-dnd' => [:with_dnd, true], '--brief' => [:brief, true],
+                  '--no-scheduled' => [:scheduled, false] }.freeze
+
       def handle_option(arg, args, remaining)
+        return toggle(arg) if TOGGLES.key?(arg)
+
         case arg
         when '-p', '--presence' then @options[:presence] = option_value(arg, args)
         when '-d', '--dnd' then @options[:dnd] = option_value(arg, args)
-        when '--with-dnd' then @options[:with_dnd] = true
         when '--start' then @options[:start_at] = option_value(arg, args)
         when '--end' then @options[:end_at] = option_value(arg, args)
         else super
         end
       end
 
+      # True means "consumed", the contract Base#handle_option expects back.
+      def toggle(arg) # rubocop:disable Naming/PredicateMethod
+        key, value = TOGGLES[arg]
+        @options[key] = value
+        true
+      end
+
       def help_text
         help = Support::HelpFormatter.new('slk status [text] [emoji] [duration] [options]')
         help.description('Get or set your Slack status.')
-        help.note('GET shows all workspaces by default. SET applies to primary only.')
+        help.note('GET shows status, presence, DND and anything queued to turn on later.')
+        help.note('GET covers all workspaces by default; SET applies to primary only.')
         help.note('scheduled shows all workspaces; schedule applies to primary; unschedule finds the ID owner.')
         help.note('Slack allows at most 5 scheduled statuses at a time.')
         add_examples_section(help)
@@ -66,7 +81,9 @@ module Slk
 
       def add_examples_section(help)
         help.section('EXAMPLES') do |s|
-          s.example('slk status', 'Show status (all workspaces)')
+          s.example('slk status', 'Show status, presence, DND and schedule (all workspaces)')
+          s.example('slk status --brief', 'Status text only, no extra lookups')
+          s.example('slk status --json', 'Machine-readable; null means "not checked"')
           s.example('slk status clear', 'Clear status')
           s.example('slk status "Working" :laptop:', 'Set status with emoji')
           s.example('slk status "Meeting" :calendar: 1h', 'Set status for 1 hour')
@@ -89,6 +106,7 @@ module Slk
       def add_options_section(help)
         help.section('OPTIONS') do |s|
           add_general_options(s)
+          add_getting_options(s)
           add_scheduling_options(s)
         end
       end
@@ -102,6 +120,14 @@ module Slk
         section.option('-q, --quiet', 'Suppress output')
       end
 
+      # These are ignored outside a plain `slk status` (and `scheduled`, for
+      # --json), so say so rather than leaving them looking universal.
+      def add_getting_options(section)
+        section.option('--brief', 'Getting only: skip the presence, DND and schedule lookups')
+        section.option('--no-scheduled', 'Getting only: skip the scheduled lookup, keep presence and DND')
+        section.option('--json', 'Getting only: JSON for scripts (also `slk status scheduled`)')
+      end
+
       # These are ignored outside `schedule`, so say so rather than leaving
       # --with-dnd looking like a sibling of -d/--dnd.
       def add_scheduling_options(section)
@@ -115,36 +141,116 @@ module Slk
       def get_status # rubocop:disable Naming/AccessorMethodName
         # GET defaults to all workspaces unless -w specified
         workspaces = target_workspaces_for_get
+        snapshots = workspaces.map { |workspace| snapshot_for(workspace) }
+        return render_snapshots_json(snapshots) if @options[:json]
 
-        workspaces.each do |workspace|
-          status = runner.users_api(workspace.name).get_status
-          print_workspace_status(workspaces, workspace, status)
+        snapshots.each { |snapshot| print_snapshot(snapshot, labelled: workspaces.size > 1) }
+        0
+      end
+
+      # The status text is what was asked for. Presence, DND and the pending
+      # schedule are what it is usually being read *for* — whether anyone can
+      # reach you, and whether the status is about to change on its own — so
+      # they are gathered alongside it, one call each, none of them fatal.
+      def snapshot_for(workspace)
+        status = runner.users_api(workspace.name).get_status
+        return Models::StatusSnapshot.new(workspace: workspace, status: status) unless details?
+
+        Models::StatusSnapshot.new(workspace: workspace, status: status, **workspace_details(workspace))
+      end
+
+      def workspace_details(workspace)
+        {
+          presence: detail(workspace, 'presence') { runner.users_api(workspace.name).get_presence },
+          dnd: detail(workspace, 'DND') { Models::DndState.from_api(runner.dnd_api(workspace.name).info) },
+          scheduled: pending_scheduled(workspace)
+        }
+      end
+
+      # --brief drops the extra calls; under --quiet their output is discarded,
+      # so they would buy nothing. --json prints even when quiet, and its
+      # consumers are the ones that want the detail most.
+      def details?
+        return false if @options[:brief]
+
+        @options[:json] || !@options[:quiet]
+      end
+
+      def pending_scheduled(workspace)
+        return nil unless @options[:scheduled]
+
+        detail(workspace, 'scheduled statuses') do
+          in_order(runner.custom_status_api(workspace.name).scheduled)
         end
+      end
 
+      # nil, not a blank value: the caller records "not checked", which --json
+      # reports as null. Reporting a failed DND lookup as "DND off" would say
+      # the opposite of the truth to anything reading it.
+      def detail(workspace, label)
+        return nil if @details_unavailable
+
+        yield
+      rescue RateLimitError => e
+        # Being throttled while decorating the answer is a reason to stop
+        # decorating. These calls are optional; the status reads they would
+        # crowd out are not.
+        @details_unavailable = true
+        warn("Rate limited; skipping presence, DND and scheduled lookups: #{e.message}")
+        nil
+      rescue ApiError => e
+        warn("Could not read #{label} on #{workspace.name}: #{e.message}")
+        nil
+      end
+
+      def render_snapshots_json(snapshots)
+        output_json(json_formatter.format(snapshots))
         0
       end
 
+      def json_formatter = Formatters::JsonStatusFormatter.new
+
+      def print_snapshot(snapshot, labelled:)
+        puts output.bold(snapshot.workspace_name) if labelled
+        print_status_line(snapshot)
+        print_upcoming(snapshot.scheduled)
+      end
+
+      # A status that turns on this afternoon is the reason to leave the
+      # current one alone, so it is listed under it rather than a command away.
+      def print_upcoming(scheduled)
+        return if scheduled.nil? || scheduled.empty?
+
+        puts '  Scheduled:'
+        # No IDs here; `slk status scheduled` is the view you paste from.
+        scheduled.each { |status| puts "    #{status}" }
+      end
+
       def target_workspaces_for_get
         @options[:workspace] ? [runner.workspace(@options[:workspace])] : runner.all_workspaces
       end
 
-      def print_workspace_status(workspaces, workspace, status)
-        puts output.bold(workspace.name) if workspaces.size > 1
+      def print_status_line(snapshot)
+        suffix = snapshot.labels.join(' ')
 
-        if status.empty?
-          puts '  (no status set)'
+        if snapshot.status.empty?
+          # Away or on DND with no status is still worth saying: it is the
+          # difference between "nothing to report" and "unreachable".
+          puts join_suffix('  (no status set)', suffix)
         else
-          display_status(workspace, status)
+          display_status(snapshot.workspace, snapshot.status, suffix)
         end
       end
 
-      def display_status(workspace, status)
+      def join_suffix(line, suffix) = suffix.empty? ? line : "#{line} #{suffix}"
+
+      def display_status(workspace, status, suffix = '')
         emoji_path = workspace_emoji_path(workspace.name, status.emoji)
 
         if emoji_path && inline_images_supported?
-          print_status_with_image(emoji_path, status)
+          print_status_with_image(emoji_path, status, suffix)
         else
-          puts "  #{status}"
+          puts join_suffix("  #{status}", suffix)
         end
       end
 
@@ -153,10 +259,11 @@ module Slk
         find_workspace_emoji(workspace_name, emoji_name)
       end
 
-      def print_status_with_image(emoji_path, status)
+      def print_status_with_image(emoji_path, status, suffix = '')
         parts = []
         parts << status.text unless status.text.empty?
         parts << "(#{status.time_remaining})" if status.time_remaining
+        parts << suffix unless suffix.empty?
         print_inline_image_with_text(emoji_path, "  #{parts.join(' ')}")
       end
 
@@ -347,6 +454,7 @@ module Slk
 
       def list_scheduled
         workspaces = target_workspaces_for_get
+        return list_scheduled_json(workspaces) if @options[:json]
 
         each_workspace_reporting(workspaces) do |workspace|
           puts output.bold(workspace.name) if workspaces.size > 1
@@ -354,12 +462,29 @@ module Slk
         end
       end
 
+      # Every workspace appears whether or not its lookup worked, so the array
+      # still lines up with the workspaces asked about; a failed one is null
+      # rather than an empty list, and its reason went to stderr.
+      def list_scheduled_json(workspaces)
+        pending = workspaces.to_h { |workspace| [workspace.name, nil] }
+
+        code = each_workspace_reporting(workspaces) do |workspace|
+          pending[workspace.name] = in_order(runner.custom_status_api(workspace.name).scheduled)
+        end
+
+        output_json(json_formatter.format_scheduled(pending))
+        code
+      end
+
       def print_scheduled(scheduled)
         return puts '  (none scheduled)' if scheduled.empty?
 
-        scheduled.each { |status| puts "  #{status.id}  #{status}" }
+        in_order(scheduled).each { |status| puts "  #{status.id}  #{status}" }
       end
 
+      # Soonest first: the next one to turn on is the one being read for.
+      def in_order(scheduled) = scheduled.sort_by(&:date_scheduled)
+
       def unschedule_status(args)
         id = args.first
         return error('Usage: slk status unschedule <id>') if id.to_s.strip.empty?

data/lib/slk/formatters/json_status_formatter.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Slk
+  module Formatters
+    # Renders `slk status` snapshots as JSON for scripts and statuslines.
+    #
+    # Two shape rules the consumers depend on:
+    #
+    #   - Always an array, one entry per workspace, even for a single one. The
+    #     workspace set changes with -w/--all, and a document whose shape
+    #     changes with a flag cannot be parsed by a script that did not pass it.
+    #   - null means "not checked" (skipped, or the lookup failed); an empty
+    #     array or false means checked. A statusline that treats a failed DND
+    #     lookup as "DND off" would quietly say the opposite of the truth.
+    #
+    # Timestamps appear twice: the raw Slack epoch under Slack's own field name
+    # and an ISO 8601 string beside it, so neither jq nor the shell has to do
+    # date arithmetic to print "until 3:00pm".
+    class JsonStatusFormatter
+      def format(snapshots)
+        snapshots.map { |snapshot| snapshot_hash(snapshot) }
+      end
+
+      # `slk status scheduled --json`: the same array, narrowed to the part
+      # that command is about, so a script can read either with one shape.
+      #
+      # @param by_workspace [Hash{String => Array<Models::ScheduledStatus>, nil}]
+      def format_scheduled(by_workspace)
+        by_workspace.map do |name, scheduled|
+          { workspace: name, scheduled: scheduled&.map { |status| scheduled_hash(status) } }
+        end
+      end
+
+      private
+
+      def snapshot_hash(snapshot)
+        {
+          workspace: snapshot.workspace_name,
+          status: status_hash(snapshot.status),
+          presence: presence_hash(snapshot.presence),
+          dnd: dnd_hash(snapshot.dnd),
+          scheduled: snapshot.scheduled&.map { |status| scheduled_hash(status) }
+        }
+      end
+
+      def status_hash(status)
+        {
+          text: status.text,
+          emoji: status.emoji,
+          # Slack's own 0-for-never, kept as-is; `expires_at` is the readable
+          # form and is null rather than "1970-01-01" when there is no expiry.
+          expiration: status.expiration,
+          expires_at: iso8601(status.expiration_time),
+          empty: status.empty?
+        }
+      end
+
+      def presence_hash(presence)
+        return nil unless presence
+
+        { presence: presence[:presence], manual_away: presence[:manual_away], online: presence[:online] }
+      end
+
+      def dnd_hash(dnd)
+        return nil unless dnd
+
+        {
+          active: dnd.active?,
+          source: dnd.source&.to_s,
+          snoozing: dnd.snoozing,
+          in_scheduled_hours: dnd.in_scheduled_hours?,
+          until: dnd.until_time&.to_i,
+          until_at: iso8601(dnd.until_time)
+        }
+      end
+
+      # Slack's own field names and epochs, plus a readable form of each
+      # timestamp. `slice` rather than the whole record on purpose: this is a
+      # published shape, and a field added to the model later should not join
+      # it without someone deciding to.
+      def scheduled_hash(status)
+        status.to_h.slice(:id, :text, :emoji, :date_scheduled, :date_expire, :dnd, :active)
+              .merge(starts_at: iso8601(status.starts_at), ends_at: iso8601(status.ends_at))
+      end
+
+      def iso8601(time) = time&.iso8601
+    end
+  end
+end

data/lib/slk/models/dnd_state.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Slk
+  module Models
+    # Current Do Not Disturb state for one workspace, from dnd.info.
+    #
+    # Slack reports two independent things through that one endpoint: a manual
+    # snooze ("pause notifications for 2 hours") and the configured DND
+    # schedule ("quiet from 8pm to 8am"). From the outside they are the same
+    # thing — messages do not notify — so `active?` covers both and `source`
+    # says which one is responsible.
+    DndState = Data.define(:snoozing, :snooze_endtime, :scheduled, :next_start, :next_end) do
+      def self.from_api(data)
+        data = {} unless data.is_a?(Hash)
+
+        new(
+          snoozing: data['snooze_enabled'] == true,
+          snooze_endtime: data['snooze_endtime'].to_i,
+          scheduled: data['dnd_enabled'] == true,
+          next_start: data['next_dnd_start_ts'].to_i,
+          next_end: data['next_dnd_end_ts'].to_i
+        )
+      end
+
+      def active? = snoozing || in_scheduled_hours?
+
+      # `next_dnd_*` names the *next* window while DND hours are off and the
+      # current one while they are running, so "now falls inside it" is the
+      # only reading that means notifications are being held right now.
+      #
+      # Slack reports 1 for both schedule timestamps when no schedule is
+      # configured, so a bare `positive?` would read that as a window that
+      # opened in 1970 and never closed.
+      def in_scheduled_hours?
+        return false unless scheduled && next_start > 1 && next_end > next_start
+
+        now = Time.now.to_i
+        next_start <= now && now < next_end
+      end
+
+      def source
+        return :both if snoozing && in_scheduled_hours?
+        return :snooze if snoozing
+        return :schedule if in_scheduled_hours?
+
+        nil
+      end
+
+      # The later of the two when both apply: notifications stay off until
+      # every reason for holding them has expired, not the first.
+      def until_time
+        finishes = []
+        finishes << snooze_endtime if snoozing && snooze_endtime.positive?
+        finishes << next_end if in_scheduled_hours?
+
+        finish = finishes.max
+        finish ? Time.at(finish) : nil
+      end
+
+      # Same-day times need no date; an overnight schedule ending tomorrow
+      # morning would otherwise read as "until 8:00am" of a day already gone.
+      def until_label
+        finish = until_time or return nil
+        finish.to_date == Date.today ? finish.strftime('%-l:%M%P') : finish.strftime('%a %-l:%M%P')
+      end
+
+      # Empty when notifications are flowing: there is nothing to say, and a
+      # "[dnd off]" on every line would bury the workspace where it is on.
+      def to_s
+        return '' unless active?
+
+        label = until_label
+        # A snooze with no end time is a state Slack can report; saying "[dnd]"
+        # is honest about not knowing when it lifts.
+        label ? "[dnd until #{label}]" : '[dnd]'
+      end
+    end
+  end
+end

data/lib/slk/models/status_snapshot.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Slk
+  module Models
+    # Everything `slk status` knows about one workspace at one moment: the
+    # status itself, plus the two things that decide whether anyone can reach
+    # you (presence, DND) and whatever is queued to replace the status later.
+    #
+    # Every part but the status is optional, and nil means "not checked" —
+    # skipped by a flag, or a lookup that failed. That is deliberately distinct
+    # from checked-and-empty: `scheduled: []` says nothing is queued, while
+    # `scheduled: nil` says nobody looked.
+    StatusSnapshot = Data.define(:workspace, :status, :presence, :dnd, :scheduled) do
+      def initialize(workspace:, status:, presence: nil, dnd: nil, scheduled: nil)
+        super
+      end
+
+      def workspace_name = workspace.name
+
+      def away? = presence ? presence[:presence] == 'away' : false
+
+      # Short suffixes for the status line. Only the exceptional states appear:
+      # active presence and DND-off are the common case, and repeating them on
+      # every line would bury the workspace that differs.
+      def labels
+        [('[away]' if away?), dnd&.to_s].reject { |label| label.to_s.empty? }
+      end
+    end
+  end
+end

data/lib/slk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Slk
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

data/lib/slk.rb

@@ -67,6 +67,8 @@ module Slk
     autoload :Workspace, 'slk/models/workspace'
     autoload :Status, 'slk/models/status'
     autoload :ScheduledStatus, 'slk/models/scheduled_status'
+    autoload :DndState, 'slk/models/dnd_state'
+    autoload :StatusSnapshot, 'slk/models/status_snapshot'
     autoload :Message, 'slk/models/message'
     autoload :Reaction, 'slk/models/reaction'
     autoload :User, 'slk/models/user'
@@ -117,6 +119,7 @@ module Slk
     autoload :MessageFormatter, 'slk/formatters/message_formatter'
     autoload :ReactionFormatter, 'slk/formatters/reaction_formatter'
     autoload :JsonMessageFormatter, 'slk/formatters/json_message_formatter'
+    autoload :JsonStatusFormatter, 'slk/formatters/json_status_formatter'
     autoload :ActivityFormatter, 'slk/formatters/activity_formatter'
     autoload :AttachmentFormatter, 'slk/formatters/attachment_formatter'
     autoload :BlockFormatter, 'slk/formatters/block_formatter'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slk
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Eric Boehs
@@ -67,6 +67,7 @@ files:
 - lib/slk/formatters/duration_formatter.rb
 - lib/slk/formatters/emoji_replacer.rb
 - lib/slk/formatters/json_message_formatter.rb
+- lib/slk/formatters/json_status_formatter.rb
 - lib/slk/formatters/markdown_output.rb
 - lib/slk/formatters/mention_replacer.rb
 - lib/slk/formatters/message_formatter.rb
@@ -79,6 +80,7 @@ files:
 - lib/slk/formatters/search_formatter.rb
 - lib/slk/formatters/text_processor.rb
 - lib/slk/models/channel.rb
+- lib/slk/models/dnd_state.rb
 - lib/slk/models/duration.rb
 - lib/slk/models/message.rb
 - lib/slk/models/preset.rb
@@ -89,6 +91,7 @@ files:
 - lib/slk/models/scheduled_status.rb
 - lib/slk/models/search_result.rb
 - lib/slk/models/status.rb
+- lib/slk/models/status_snapshot.rb
 - lib/slk/models/user.rb
 - lib/slk/models/workspace.rb
 - lib/slk/runner.rb
@@ -152,7 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.13
+rubygems_version: 4.0.16
 specification_version: 4
 summary: A command-line interface for Slack
 test_files: []