slk 0.4.0 → 0.4.2

data/lib/slk/formatters/markdown_output.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Slk
+  module Formatters
+    # Markdown output adapter with same interface as Output
+    # Produces markdown formatting instead of ANSI colors
+    class MarkdownOutput
+      attr_reader :verbose, :quiet
+
+      # Accept color: parameter for interface compatibility with Output (ignored for markdown)
+      def initialize(io: $stdout, err: $stderr, color: nil, verbose: false, quiet: false) # rubocop:disable Lint/UnusedMethodArgument
+        @io = io
+        @err = err
+        @verbose = verbose
+        @quiet = quiet
+      end
+
+      def puts(message = '')
+        @io.puts(message) unless @quiet
+      end
+
+      def print(message)
+        @io.print(message) unless @quiet
+      end
+
+      def error(message)
+        @err.puts("**Error:** #{message}")
+      end
+
+      def warn(message)
+        @err.puts("*Warning:* #{message}") unless @quiet
+      end
+
+      def success(message)
+        puts("✓ #{message}")
+      end
+
+      def info(message)
+        puts(message)
+      end
+
+      def debug(message)
+        return unless @verbose
+
+        @err.puts("*[debug]* #{message}")
+      end
+
+      # Markdown formatting helpers - string interpolation handles nil conversion
+      # bold -> **text**
+      def bold(text)
+        "**#{text}**"
+      end
+
+      # red -> **text** (emphasis for errors)
+      def red(text)
+        "**#{text}**"
+      end
+
+      # green -> plain text (success doesn't need markup)
+      def green(text)
+        text.to_s
+      end
+
+      # yellow -> *text* (italics for warnings)
+      def yellow(text)
+        "*#{text}*"
+      end
+
+      # blue -> `text` (code for timestamps)
+      def blue(text)
+        "`#{text}`"
+      end
+
+      # magenta -> *text* (italics for secondary)
+      def magenta(text)
+        "*#{text}*"
+      end
+
+      # cyan -> `text` (code for metadata like timestamps)
+      def cyan(text)
+        "`#{text}`"
+      end
+
+      # gray -> *text* (italics for secondary info)
+      def gray(text)
+        "*#{text}*"
+      end
+
+      def with_verbose(value)
+        self.class.new(io: @io, err: @err, verbose: value, quiet: @quiet)
+      end
+
+      def with_quiet(value)
+        self.class.new(io: @io, err: @err, verbose: @verbose, quiet: value)
+      end
+    end
+  end
+end

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