slk 0.4.0 → 0.4.1

data/lib/slk/formatters/message_formatter.rb

@@ -6,13 +6,16 @@ module Slk
     # rubocop:disable Metrics/ClassLength
     class MessageFormatter
       # rubocop:disable Metrics/ParameterLists
-      def initialize(output:, mention_replacer:, emoji_replacer:, cache_store:, api_client: nil, on_debug: nil)
+      def initialize(output:, mention_replacer:, emoji_replacer:, cache_store:, api_client: nil,
+                     text_processor: nil, on_debug: nil)
         @output = output
-        @mentions = mention_replacer
-        @emoji = emoji_replacer
         @cache = cache_store
         @api_client = api_client
         @on_debug = on_debug
+        @text_processor = text_processor || TextProcessor.new(
+          mention_replacer: mention_replacer,
+          emoji_replacer: emoji_replacer
+        )
         @reaction_formatter = build_reaction_formatter(output, emoji_replacer, cache_store)
         @json_formatter = JsonMessageFormatter.new(cache_store: cache_store)
       end
@@ -25,7 +28,7 @@ module Slk
       def format(message, workspace:, options: {})
         username = resolve_username(message, workspace, options)
         timestamp = format_timestamp(message.timestamp)
-        text = process_text(message.text, workspace, options)
+        text = @text_processor.process(message.text, workspace, options)
 
         header = build_header(timestamp, username)
         display_text = build_display_text(text, message, header, options)
@@ -37,7 +40,7 @@ module Slk
       def format_simple(message, workspace:, options: {})
         username = resolve_username(message, workspace, options)
         timestamp = format_timestamp(message.timestamp)
-        text = process_text(message.text, workspace, options)
+        text = @text_processor.process(message.text, workspace, options)
 
         reaction_text = ''
         unless options[:no_reactions] || message.reactions.empty?
@@ -88,7 +91,7 @@ module Slk
 
       def build_output_lines(main_line, message, workspace, options, display_text)
         lines = [main_line]
-        text_processor = ->(txt) { process_text(txt, workspace, options) }
+        text_processor = ->(txt) { @text_processor.process(txt, workspace, options) }
 
         BlockFormatter.new(text_processor: text_processor)
                       .format(message.blocks, message.text, lines, options)
@@ -118,18 +121,7 @@ module Slk
       end
 
       def format_timestamp(time)
-        time.strftime('%Y-%m-%d %H:%M')
-      end
-
-      def process_text(text, workspace, options)
-        result = decode_html_entities(text.dup)
-        result = @mentions.replace(result, workspace)
-        result = @emoji.replace(result, workspace) unless options[:no_emoji]
-        result
-      end
-
-      def decode_html_entities(text)
-        text.gsub('&amp;', '&').gsub('&lt;', '<').gsub('&gt;', '>')
+        time.strftime('%Y-%m-%d %H:%M:%S')
       end
 
       def format_files(message, lines, options, skip_first: false)

data/lib/slk/formatters/reaction_formatter.rb

@@ -80,7 +80,7 @@ module Slk
 
       def format_time(slack_timestamp)
         time = Time.at(slack_timestamp.to_f)
-        time.strftime('%-I:%M %p') # e.g., "2:45 PM"
+        time.strftime('%-I:%M:%S %p') # e.g., "2:45:30 PM"
       end
     end
   end

data/lib/slk/formatters/saved_item_formatter.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Slk
+  module Formatters
+    # Formats saved/later items for terminal display
+    class SavedItemFormatter
+      def initialize(output:, mention_replacer:, text_processor:, on_debug: nil)
+        @output = output
+        @mentions = mention_replacer
+        @text_processor = text_processor
+        @on_debug = on_debug
+      end
+
+      # Display a single saved item
+      # @param truncate [Boolean] if true, truncate to single line at width instead of wrapping
+      def display_item(item, workspace, message: nil, width: nil, truncate: false)
+        status_badge = format_status_badge(item)
+        due_info = format_due_info(item)
+
+        # First line: status badge and due info
+        header_parts = [status_badge, due_info].compact.reject(&:empty?)
+        @output.puts header_parts.join(' | ') unless header_parts.empty?
+
+        # Message content
+        display_message(message, workspace, width: width, truncate: truncate) if message
+        @output.puts # blank line between items
+      end
+
+      private
+
+      # rubocop:disable Metrics/MethodLength
+      def format_status_badge(item)
+        badge = case item.state
+                when 'completed' then '[completed]'
+                when 'in_progress' then '[in_progress]'
+                when 'saved' then '[saved]'
+                else "[#{item.state}]"
+                end
+
+        # Color based on overdue status
+        if item.overdue?
+          @output.red(badge)
+        elsif item.state == 'completed'
+          @output.green(badge)
+        elsif item.state == 'in_progress'
+          @output.yellow(badge)
+        else
+          @output.blue(badge)
+        end
+      end
+
+      # rubocop:enable Metrics/MethodLength
+
+      def format_due_info(item)
+        return '' unless item.due_date?
+
+        time_diff = item.time_until_due
+        formatted = format_time_difference(time_diff)
+
+        if item.overdue?
+          "Due: #{@output.red(formatted)}"
+        else
+          "Due: #{formatted}"
+        end
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def format_time_difference(seconds)
+        abs_seconds = seconds.abs
+        ago = seconds.negative?
+
+        formatted = if abs_seconds < 60
+                      "#{abs_seconds}s"
+                    elsif abs_seconds < 3600
+                      "#{abs_seconds / 60}m"
+                    elsif abs_seconds < 86_400
+                      "#{abs_seconds / 3600}h"
+                    else
+                      "#{abs_seconds / 86_400}d"
+                    end
+
+        ago ? "#{formatted} ago" : "in #{formatted}"
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def display_message(message, workspace, width: nil, truncate: false)
+        username = resolve_message_author(message, workspace)
+        text = prepare_message_text(message, workspace)
+        header = "  #{@output.bold(username)}: "
+        header_width = Support::TextWrapper.visible_length(header)
+
+        if truncate
+          display_truncated_message(header, text, width, header_width)
+        else
+          display_wrapped_message(header, text, width, header_width)
+        end
+      end
+
+      def display_truncated_message(header, text, width, header_width)
+        # Single line, truncated at width
+        first_line = text.lines.first&.strip || text
+        max_text_width = width ? [width - header_width, 10].max : 100
+        @output.puts "#{header}#{truncate_text(first_line, max_text_width)}"
+      end
+
+      def display_wrapped_message(header, text, width, header_width)
+        # Full message with wrapping
+        wrapped = wrap_text(text, header_width, width)
+        lines = wrapped.lines
+
+        first_line = lines.first&.rstrip || wrapped
+        @output.puts "#{header}#{first_line}"
+        lines[1..].each { |line| @output.puts "  #{line.rstrip}" } if lines.length > 1
+      end
+
+      def resolve_message_author(message, workspace)
+        if message['user']
+          @mentions.lookup_user_name(workspace, message['user']) || message['user']
+        elsif message['bot_id']
+          'Bot'
+        else
+          'Unknown'
+        end
+      end
+
+      def prepare_message_text(message, workspace)
+        @text_processor.process(message['text'], workspace)
+      end
+
+      def wrap_text(text, indent_width, width)
+        return text if text.empty? || !width
+
+        # If header is wider than target, first line gets no wrap, subsequent lines wrap at width - 2
+        first_line_width = [width - indent_width, 10].max
+        continuation_width = [width - 2, 10].max
+        Support::TextWrapper.wrap(text, first_line_width, continuation_width)
+      end
+
+      def truncate_text(text, max_length)
+        text.length > max_length ? "#{text[0...max_length]}..." : text
+      end
+    end
+  end
+end

data/lib/slk/formatters/search_formatter.rb

@@ -4,10 +4,10 @@ module Slk
   module Formatters
     # Formats search results for terminal display
     class SearchFormatter
-      def initialize(output:, emoji_replacer:, mention_replacer:)
+      def initialize(output:, mention_replacer:, text_processor:)
         @output = output
-        @emoji = emoji_replacer
         @mentions = mention_replacer
+        @text_processor = text_processor
       end
 
       # Display a list of search results
@@ -54,11 +54,7 @@ module Slk
       end
 
       def prepare_text(text, workspace, options)
-        return text if options[:no_emoji] && options[:no_mentions]
-
-        text = @emoji.replace(text) unless options[:no_emoji]
-        text = @mentions.replace(text, workspace) unless options[:no_mentions]
-        text
+        @text_processor.process(text, workspace, options)
       end
 
       def display_files(files)
@@ -68,7 +64,7 @@ module Slk
       end
 
       def format_time(time)
-        time.strftime('%Y-%m-%d %H:%M')
+        time.strftime('%Y-%m-%d %H:%M:%S')
       end
     end
   end

data/lib/slk/formatters/text_processor.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Slk
+  module Formatters
+    # Centralized text processing for message display
+    # Handles HTML entity decoding, mention replacement, and emoji replacement
+    class TextProcessor
+      def initialize(mention_replacer:, emoji_replacer:)
+        @mentions = mention_replacer
+        @emoji = emoji_replacer
+      end
+
+      # Process raw Slack message text for display
+      # @param text [String] Raw message text from Slack API
+      # @param workspace [Models::Workspace] The workspace for name resolution
+      # @param options [Hash] Processing options
+      # @option options [Boolean] :no_emoji Skip emoji replacement
+      # @option options [Boolean] :no_mentions Skip mention replacement
+      # @return [String] Processed text ready for display
+      def process(text, workspace, options = {})
+        return '[No text]' if text.to_s.empty?
+
+        result = decode_html_entities(text.dup)
+        result = safe_replace_mentions(result, workspace) unless options[:no_mentions]
+        result = safe_replace_emoji(result, workspace) unless options[:no_emoji]
+        result
+      end
+
+      private
+
+      def decode_html_entities(text)
+        text.gsub('&amp;', '&').gsub('&lt;', '<').gsub('&gt;', '>')
+      end
+
+      def safe_replace_mentions(text, workspace)
+        @mentions.replace(text, workspace)
+      rescue StandardError
+        text
+      end
+
+      def safe_replace_emoji(text, workspace)
+        @emoji.replace(text, workspace)
+      rescue StandardError
+        text
+      end
+    end
+  end
+end

data/lib/slk/models/saved_item.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Slk
+  module Models
+    # State constants for saved items
+    SAVED_STATE_SAVED = 'saved'
+    SAVED_STATE_IN_PROGRESS = 'in_progress'
+    SAVED_STATE_COMPLETED = 'completed'
+
+    # Represents a saved/later item from Slack's saved.list API
+    # rubocop:disable Metrics/ParameterLists
+    SavedItem = Data.define(
+      :item_id,
+      :item_type,
+      :ts,
+      :state,
+      :date_created,
+      :date_due,
+      :date_completed,
+      :is_archived
+    ) do
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      def self.from_api(data)
+        new(
+          item_id: data['item_id'] || data['channel_id'] || data['conversation_id'],
+          item_type: data['item_type'] || data['type'] || 'message',
+          ts: data['ts'] || data['message_ts'],
+          state: data['state'] || SAVED_STATE_SAVED,
+          date_created: parse_timestamp(data['date_created']),
+          date_due: parse_timestamp(data['date_due']),
+          date_completed: parse_timestamp(data['date_completed']),
+          is_archived: data['is_archived'] || false
+        )
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+      def self.parse_timestamp(value)
+        return nil if value.nil? || value.to_i.zero?
+
+        value.to_i
+      end
+
+      private_class_method :parse_timestamp
+
+      # rubocop:disable Naming/MethodParameterName
+      def initialize(
+        item_id:,
+        item_type: 'message',
+        ts: nil,
+        state: SAVED_STATE_SAVED,
+        date_created: nil,
+        date_due: nil,
+        date_completed: nil,
+        is_archived: false
+      )
+        super(
+          item_id: item_id.to_s.freeze,
+          item_type: item_type.to_s.freeze,
+          ts: ts&.to_s&.freeze,
+          state: state.to_s.freeze,
+          date_created: date_created,
+          date_due: date_due,
+          date_completed: date_completed,
+          is_archived: is_archived
+        )
+      end
+      # rubocop:enable Naming/MethodParameterName
+
+      # Channel ID alias for compatibility with message fetching
+      alias_method :channel_id, :item_id
+
+      # State predicates
+      def completed?
+        state == SAVED_STATE_COMPLETED
+      end
+
+      def in_progress?
+        state == SAVED_STATE_IN_PROGRESS
+      end
+
+      def saved?
+        state == SAVED_STATE_SAVED
+      end
+
+      def archived?
+        is_archived
+      end
+
+      # Due date helpers
+      def due_date?
+        !date_due.nil?
+      end
+
+      def overdue?
+        return false unless due_date?
+        return false if completed?
+
+        date_due < Time.now.to_i
+      end
+
+      def due_time
+        return nil unless due_date?
+
+        Time.at(date_due)
+      end
+
+      def created_time
+        return nil unless date_created
+
+        Time.at(date_created)
+      end
+
+      def completed_time
+        return nil unless date_completed
+
+        Time.at(date_completed)
+      end
+
+      # Time until/since due date
+      def time_until_due
+        return nil unless due_date?
+
+        date_due - Time.now.to_i
+      end
+    end
+    # rubocop:enable Metrics/ParameterLists
+  end
+end

data/lib/slk/runner.rb

@@ -2,6 +2,7 @@
 
 module Slk
   # Dependency injection container providing services to commands
+  # rubocop:disable Metrics/ClassLength
   class Runner
     attr_reader :output, :config, :token_store, :api_client, :cache_store, :preset_store
 
@@ -83,6 +84,17 @@ module Slk
       Api::Search.new(@api_client, workspace(workspace_name))
     end
 
+    def saved_api(workspace_name = nil)
+      Api::Saved.new(@api_client, workspace(workspace_name))
+    end
+
+    def message_resolver(workspace_name = nil)
+      Services::MessageResolver.new(
+        conversations_api: conversations_api(workspace_name),
+        on_debug: ->(msg) { @output.debug(msg) }
+      )
+    end
+
     # Formatter helpers
     def message_formatter
       @message_formatter ||= Formatters::MessageFormatter.new(
@@ -107,6 +119,13 @@ module Slk
       @emoji_replacer ||= Formatters::EmojiReplacer.new
     end
 
+    def text_processor
+      @text_processor ||= Formatters::TextProcessor.new(
+        mention_replacer: mention_replacer,
+        emoji_replacer: emoji_replacer
+      )
+    end
+
     def duration_formatter
       @duration_formatter ||= Formatters::DurationFormatter.new
     end
@@ -114,8 +133,8 @@ module Slk
     def search_formatter
       @search_formatter ||= Formatters::SearchFormatter.new(
         output: @output,
-        emoji_replacer: emoji_replacer,
-        mention_replacer: mention_replacer
+        mention_replacer: mention_replacer,
+        text_processor: text_processor
       )
     end
 
@@ -135,4 +154,5 @@ module Slk
       @cache_store.on_warning = warning_handler
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/slk/services/message_resolver.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Resolves and fetches individual messages by timestamp from channels
+    # Used by activity feed, saved items, and other features that need to
+    # fetch message content by ts.
+    class MessageResolver
+      def initialize(conversations_api:, on_debug: nil)
+        @api = conversations_api
+        @on_debug = on_debug
+      end
+
+      # Fetch a single message by its timestamp from a channel
+      # @param channel_id [String] The channel ID
+      # @param message_ts [String] The message timestamp
+      # @return [Hash, nil] The message data or nil if not found
+      def fetch_by_ts(channel_id, message_ts)
+        response = fetch_message_history(channel_id, message_ts)
+        return nil unless response['ok'] && response['messages']&.any?
+
+        response['messages'].find { |msg| msg['ts'] == message_ts }
+      rescue ApiError => e
+        @on_debug&.call("Could not fetch message #{message_ts} from #{channel_id}: #{e.message}")
+        nil
+      end
+
+      private
+
+      def fetch_message_history(channel_id, message_ts)
+        # Use a narrow time window around the message timestamp
+        oldest_ts = (message_ts.to_f - 1).to_s
+        latest_ts = (message_ts.to_f + 1).to_s
+        @api.history(channel: channel_id, limit: 10, oldest: oldest_ts, latest: latest_ts)
+      end
+    end
+  end
+end

data/lib/slk/support/inline_images.rb

@@ -2,11 +2,17 @@
 
 module Slk
   module Support
-    # Shared module for inline image display in iTerm2/WezTerm/Mintty terminals
+    # Shared module for inline image display in terminals supporting
+    # iTerm2 protocol (iTerm2/WezTerm/Mintty) or Kitty graphics protocol (Ghostty/Kitty)
     # Includes special handling for tmux passthrough sequences
     module InlineImages
-      # Check if terminal supports iTerm2 inline image protocol
+      # Check if terminal supports any inline image protocol
       def inline_images_supported?
+        iterm2_protocol_supported? || kitty_graphics_supported?
+      end
+
+      # Check if terminal supports iTerm2 inline image protocol
+      def iterm2_protocol_supported?
         # iTerm2, WezTerm, Mintty support inline images
         # LC_TERMINAL persists through tmux/ssh
         ['iTerm.app', 'WezTerm'].include?(ENV.fetch('TERM_PROGRAM', nil)) ||
@@ -15,31 +21,88 @@ module Slk
           ENV['TERM'] == 'mintty'
       end
 
+      # Check if terminal supports Kitty graphics protocol (Ghostty, Kitty)
+      def kitty_graphics_supported?
+        ENV['TERM_PROGRAM'] == 'ghostty' ||
+          ENV['GHOSTTY_RESOURCES_DIR'] ||
+          ENV['TERM']&.include?('kitty') ||
+          tmux_client_is_kitty_compatible?
+      end
+
+      # Check if tmux client terminal supports Kitty graphics
+      def tmux_client_is_kitty_compatible?
+        return false unless in_tmux?
+
+        @tmux_client_is_kitty_compatible ||= begin
+          output = begin
+            `tmux display-message -p '\#{client_termname}'`.chomp
+          rescue StandardError
+            ''
+          end
+          output.include?('ghostty') || output.include?('kitty')
+        end
+      end
+
       # Check if running inside tmux
       def in_tmux?
         # tmux sets TERM to screen-* or tmux-*
         ENV['TERM']&.include?('screen') || ENV['TERM']&.start_with?('tmux')
       end
 
-      # Print an inline image using iTerm2 protocol
+      # Print an inline image using the appropriate protocol
       # In tmux, uses passthrough sequence and cursor positioning
       def print_inline_image(path, height: 1)
-        data = read_image_data(path)
+        data = read_image_data_for_protocol(path)
         return unless data
 
         encoded = [data].pack('m0')
-        in_tmux? ? print_tmux_image(encoded, height) : print_iterm_image(encoded, height)
+
+        if kitty_graphics_supported?
+          in_tmux? ? print_tmux_kitty_image(encoded, height) : print_kitty_image(encoded, height)
+        else
+          in_tmux? ? print_tmux_iterm_image(encoded, height) : print_iterm_image(encoded, height)
+        end
       end
 
-      def read_image_data(path)
+      def read_image_data_for_protocol(path)
         return nil unless File.exist?(path)
 
-        File.binread(path)
+        data = File.binread(path)
+        return nil unless data
+
+        # Kitty protocol requires PNG format; convert GIF/JPEG if needed
+        if kitty_graphics_supported? && !png_data?(data)
+          convert_to_png(path)
+        else
+          data
+        end
       rescue IOError, SystemCallError
         nil
       end
 
-      def print_tmux_image(encoded, height)
+      def png_data?(data)
+        # PNG files start with magic bytes: 137 80 78 71 13 10 26 10
+        data[0, 8]&.bytes == [137, 80, 78, 71, 13, 10, 26, 10]
+      end
+
+      def convert_to_png(path)
+        # Use sips (macOS) to convert to PNG
+        require 'tempfile'
+        temp = Tempfile.new(['emoji', '.png'])
+        temp.close
+
+        system('sips', '-s', 'format', 'png', path, '--out', temp.path,
+               out: File::NULL, err: File::NULL)
+
+        return nil unless File.exist?(temp.path) && File.size(temp.path).positive?
+
+        File.binread(temp.path)
+      ensure
+        temp&.unlink
+      end
+
+      # iTerm2 protocol methods
+      def print_tmux_iterm_image(encoded, height)
         fmt = "\ePtmux;\e\e]1337;File=inline=1;preserveAspectRatio=0;" \
               "size=%<size>d;height=%<height>d:%<data>s\a\e\\\n "
         printf fmt, size: encoded.length, height: height, data: encoded
@@ -49,6 +112,26 @@ module Slk
         printf "\e]1337;File=inline=1;height=%<height>d:%<data>s\a", height: height, data: encoded
       end
 
+      # Kitty graphics protocol methods (Ghostty, Kitty)
+      # a=T: transmit and display, q=1: suppress OK response, f=100: PNG, r=rows, m=0: no more chunks
+      def print_kitty_image(encoded, height)
+        printf "\e_Ga=T,q=1,f=100,r=%<height>d,m=0;%<data>s\e\\", height: height, data: encoded
+      end
+
+      # Kitty graphics with Unicode placeholders for tmux (images clear/scroll with text)
+      # See: https://sw.kovidgoyal.net/kitty/graphics-protocol/#unicode-placeholders
+      def print_tmux_kitty_image(encoded, _height)
+        @kitty_image_id ||= 30
+        @kitty_image_id = (@kitty_image_id % 255) + 1
+        image_id = @kitty_image_id
+
+        # tmux passthrough: transmit image with Unicode placeholder mode (U=1), 2 cols x 1 row
+        $stdout.print "\ePtmux;\e\e_Ga=T,U=1,q=1,f=100,i=#{image_id},c=2,r=1,m=0;#{encoded}\e\e\\\e\\"
+        # Output placeholder cells (U+10EEEE + row/col diacritics) with foreground color = image_id
+        $stdout.print "\e[38;5;#{image_id}m\u{10EEEE}\u0305\u0305\u{10EEEE}\u0305\u030D\e[39m"
+        $stdout.flush
+      end
+
       # Print inline image with name on same line
       # Handles tmux cursor positioning to keep image and text on same line
       def print_inline_image_with_text(path, text, height: 1) # rubocop:disable Naming/PredicateMethod
@@ -56,11 +139,12 @@ module Slk
 
         print_inline_image(path, height: height)
 
-        if in_tmux?
-          # tmux: image ends with \n + space, cursor on next line
+        if in_tmux? && !kitty_graphics_supported?
+          # iTerm2 in tmux: image ends with \n + space, cursor on next line
           # Move up 1 line, right 3 cols (past image), then print text
           print "\e[1A\e[3C#{text}\n"
         else
+          # Direct output or Unicode placeholders (regular text, just print after)
           puts " #{text}"
         end
 

data/lib/slk/version.rb

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