slk 0.1.0 → 0.2.0

data/lib/slk/formatters/json_message_formatter.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Slk
+  module Formatters
+    # Formats Slack messages as JSON for structured output
+    class JsonMessageFormatter
+      def initialize(cache_store:)
+        @cache = cache_store
+      end
+
+      # Format a message as a JSON-serializable hash
+      def format(message, workspace: nil, options: {})
+        result = build_base_result(message)
+        result[:reactions] = format_reactions(message.reactions, workspace, options)
+
+        add_user_name(result, message, workspace, options)
+        add_channel_info(result, workspace, options)
+
+        result
+      end
+
+      private
+
+      def build_base_result(message)
+        {
+          ts: message.ts,
+          user_id: message.user_id,
+          text: message.text,
+          reply_count: message.reply_count,
+          thread_ts: message.thread_ts,
+          attachments: message.attachments,
+          files: message.files
+        }
+      end
+
+      def format_reactions(reactions, workspace, options)
+        reactions.map do |r|
+          reaction_hash = { name: r.name, count: r.count }
+          reaction_hash[:users] = format_reaction_users(r, workspace, options)
+          reaction_hash
+        end
+      end
+
+      def format_reaction_users(reaction, workspace, options)
+        workspace_name = workspace&.name
+
+        reaction.users.map do |user_id|
+          user_hash = { id: user_id }
+          add_user_reaction_name(user_hash, user_id, workspace_name, options)
+          add_user_reaction_timestamp(user_hash, reaction, user_id)
+          user_hash
+        end
+      end
+
+      def add_user_reaction_name(user_hash, user_id, workspace_name, options)
+        return if options[:no_names]
+        return unless workspace_name
+
+        cached_name = @cache.get_user(workspace_name, user_id)
+        user_hash[:name] = cached_name if cached_name
+      end
+
+      def add_user_reaction_timestamp(user_hash, reaction, user_id)
+        return unless reaction.timestamps?
+
+        timestamp = reaction.timestamp_for(user_id)
+        return unless timestamp
+
+        user_hash[:reacted_at] = timestamp
+        user_hash[:reacted_at_iso8601] = Time.at(timestamp.to_f).iso8601
+      end
+
+      def add_user_name(result, message, workspace, options)
+        return if options[:no_names]
+
+        workspace_name = workspace&.name
+        return unless workspace_name
+
+        user_name = @cache.get_user(workspace_name, message.user_id)
+        result[:user_name] = user_name if user_name
+      end
+
+      def add_channel_info(result, workspace, options)
+        return unless options[:channel_id]
+
+        result[:channel_id] = options[:channel_id]
+        workspace_name = workspace&.name
+        return unless workspace_name
+
+        channel_name = @cache.get_channel_name(workspace_name, options[:channel_id])
+        result[:channel_name] = channel_name if channel_name
+      end
+    end
+  end
+end

data/lib/slk/formatters/mention_replacer.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Slk
+  module Formatters
+    # Replaces Slack mention syntax with readable @names and #channels
+    # rubocop:disable Metrics/ClassLength
+    class MentionReplacer
+      USER_MENTION_REGEX = /<@([UW][A-Z0-9]+)(?:\|([^>]+))?>/
+      CHANNEL_MENTION_REGEX = /<#([A-Z0-9]+)(?:\|([^>]*))?>/
+      SUBTEAM_MENTION_REGEX = /<!subteam\^([A-Z0-9]+)(?:\|@?([^>]+))?>/
+      LINK_REGEX = %r{<(https?://[^|>]+)(?:\|([^>]+))?>}
+      SPECIAL_MENTIONS = {
+        '<!here>' => '@here',
+        '<!channel>' => '@channel',
+        '<!everyone>' => '@everyone'
+      }.freeze
+
+      def initialize(cache_store:, api_client: nil, on_debug: nil)
+        @cache = cache_store
+        @api = api_client
+        @on_debug = on_debug
+      end
+
+      def replace(text, workspace)
+        result = text.dup
+        result = replace_user_mentions(result, workspace)
+        result = replace_channel_mentions(result, workspace)
+        result = replace_subteam_mentions(result, workspace)
+        result = replace_links(result)
+        replace_special_mentions(result)
+      end
+
+      private
+
+      def replace_user_mentions(text, workspace)
+        text.gsub(USER_MENTION_REGEX) do
+          user_id = ::Regexp.last_match(1)
+          display_name = ::Regexp.last_match(2)
+          name = display_name_or_lookup(display_name, workspace, user_id, :user)
+          "@#{name}"
+        end
+      end
+
+      def replace_channel_mentions(text, workspace)
+        text.gsub(CHANNEL_MENTION_REGEX) do
+          channel_id = ::Regexp.last_match(1)
+          channel_name = ::Regexp.last_match(2)
+          name = display_name_or_lookup(channel_name, workspace, channel_id, :channel)
+          "##{name}"
+        end
+      end
+
+      def replace_subteam_mentions(text, workspace)
+        text.gsub(SUBTEAM_MENTION_REGEX) do
+          subteam_id = ::Regexp.last_match(1)
+          handle = ::Regexp.last_match(2)
+          name = display_name_or_lookup(handle, workspace, subteam_id, :subteam)
+          "@#{name}"
+        end
+      end
+
+      def replace_links(text)
+        text.gsub(LINK_REGEX) { ::Regexp.last_match(2) || ::Regexp.last_match(1) }
+      end
+
+      def replace_special_mentions(text)
+        SPECIAL_MENTIONS.each { |pattern, replacement| text.gsub!(pattern, replacement) }
+        text
+      end
+
+      def display_name_or_lookup(display_name, workspace, id, type)
+        return display_name unless display_name.to_s.empty?
+
+        lookup_by_type(workspace, id, type) || id
+      end
+
+      def lookup_by_type(workspace, id, type)
+        case type
+        when :user then lookup_user_name(workspace, id)
+        when :channel then lookup_channel_name(workspace, id)
+        when :subteam then lookup_subteam_handle(workspace, id)
+        end
+      end
+
+      def lookup_user_name(workspace, user_id)
+        cached = @cache.get_user(workspace.name, user_id)
+        return cached if cached
+
+        fetch_user_name_from_api(workspace, user_id)
+      end
+
+      def fetch_user_name_from_api(workspace, user_id)
+        return nil unless @api
+
+        response = Api::Users.new(@api, workspace).info(user_id)
+        return nil unless response['ok'] && response['user']
+
+        name = extract_user_display_name(response['user'])
+        cache_user_name(workspace, user_id, name)
+        name
+      rescue ApiError => e
+        @on_debug&.call("User lookup failed for #{user_id}: #{e.message}")
+        nil
+      end
+
+      def cache_user_name(workspace, user_id, name)
+        @cache.set_user(workspace.name, user_id, name, persist: true) unless name.to_s.empty?
+      end
+
+      def extract_user_display_name(user)
+        profile = user['profile'] || {}
+        profile['display_name'].then { |n| n.to_s.empty? ? nil : n } ||
+          profile['real_name'].then { |n| n.to_s.empty? ? nil : n } ||
+          user['name'].then { |n| n.to_s.empty? ? nil : n }
+      end
+
+      def lookup_channel_name(workspace, channel_id)
+        cached = @cache.get_channel_name(workspace.name, channel_id)
+        return cached if cached
+
+        fetch_channel_name_from_api(workspace, channel_id)
+      end
+
+      def fetch_channel_name_from_api(workspace, channel_id)
+        return nil unless @api
+
+        response = Api::Conversations.new(@api, workspace).info(channel: channel_id)
+        return nil unless response['ok'] && response['channel']
+
+        name = response['channel']['name']
+        @cache.set_channel(workspace.name, name, channel_id) if name
+        name
+      rescue ApiError => e
+        @on_debug&.call("Channel lookup failed for #{channel_id}: #{e.message}")
+        nil
+      end
+
+      def lookup_subteam_handle(workspace, subteam_id)
+        cached = @cache.get_subteam(workspace.name, subteam_id)
+        return cached if cached
+
+        fetch_subteam_handle_from_api(workspace, subteam_id)
+      end
+
+      def fetch_subteam_handle_from_api(workspace, subteam_id)
+        return nil unless @api
+
+        handle = Api::Usergroups.new(@api, workspace).get_handle(subteam_id)
+        @cache.set_subteam(workspace.name, subteam_id, handle) if handle
+        handle
+      rescue ApiError => e
+        @on_debug&.call("Subteam lookup failed for #{subteam_id}: #{e.message}")
+        nil
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/slk/formatters/message_formatter.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Slk
+  module Formatters
+    # Formats Slack messages for terminal display or JSON output
+    # 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)
+        @output = output
+        @mentions = mention_replacer
+        @emoji = emoji_replacer
+        @cache = cache_store
+        @api_client = api_client
+        @on_debug = on_debug
+        @reaction_formatter = build_reaction_formatter(output, emoji_replacer, cache_store)
+        @json_formatter = JsonMessageFormatter.new(cache_store: cache_store)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def build_reaction_formatter(output, emoji_replacer, cache_store)
+        ReactionFormatter.new(output: output, emoji_replacer: emoji_replacer, cache_store: cache_store)
+      end
+
+      def format(message, workspace:, options: {})
+        username = resolve_username(message, workspace, options)
+        timestamp = format_timestamp(message.timestamp)
+        text = process_text(message.text, workspace, options)
+
+        header = build_header(timestamp, username)
+        display_text = build_display_text(text, message, header, options)
+        main_line = "#{header} #{display_text}"
+
+        build_output_lines(main_line, message, workspace, options, display_text)
+      end
+
+      def format_simple(message, workspace:, options: {})
+        username = resolve_username(message, workspace, options)
+        timestamp = format_timestamp(message.timestamp)
+        text = process_text(message.text, workspace, options)
+
+        reaction_text = ''
+        unless options[:no_reactions] || message.reactions.empty?
+          reaction_text = format_reaction_inline(message, options)
+        end
+
+        "#{@output.blue("[#{timestamp}]")} #{@output.bold(username)}: #{text}#{reaction_text}"
+      end
+
+      def format_reaction_inline(message, options)
+        @reaction_formatter.format_inline(message.reactions, options)
+      end
+
+      def format_json(message, workspace: nil, options: {})
+        @json_formatter.format(message, workspace: workspace, options: options)
+      end
+
+      private
+
+      def build_header(timestamp, username)
+        "#{@output.blue("[#{timestamp}]")} #{@output.bold(username)}:"
+      end
+
+      def build_display_text(text, message, header, options)
+        display_text = text.strip
+        header_width = Support::TextWrapper.visible_length("#{header.gsub(/\e\[[0-9;]*m/, '')} ")
+
+        display_text = wrap_display_text(display_text, header_width, options[:width])
+        display_text = add_file_placeholder(message, options) if display_text.empty?
+
+        display_text
+      end
+
+      def wrap_display_text(text, header_width, width)
+        return text if text.empty? || !width || width <= header_width
+
+        first_line_width = width - header_width
+        Support::TextWrapper.wrap(text, first_line_width, width)
+      end
+
+      def add_file_placeholder(message, options)
+        return '' unless message.files? && !options[:no_files]
+
+        first_file = message.files.first
+        file_name = first_file['name'] || 'file'
+        @output.blue("[File: #{file_name}]")
+      end
+
+      def build_output_lines(main_line, message, workspace, options, display_text)
+        lines = [main_line]
+        text_processor = ->(txt) { process_text(txt, workspace, options) }
+
+        BlockFormatter.new(text_processor: text_processor)
+                      .format(message.blocks, message.text, lines, options)
+        AttachmentFormatter.new(output: @output, text_processor: text_processor)
+                           .format(message.attachments, lines, options)
+        format_files(message, lines, options, skip_first: display_text.include?('[File:'))
+        format_reactions(message, lines, workspace, options)
+        format_thread_indicator(message, lines, options)
+
+        lines.join("\n")
+      end
+
+      def resolve_username(message, workspace, options = {})
+        return message.user_id if options[:no_names]
+        return message.embedded_username if message.embedded_username
+
+        cached = @cache.get_user(workspace.name, message.user_id)
+        return cached if cached
+
+        lookup_bot_if_needed(message, workspace) || message.user_id
+      end
+
+      def lookup_bot_if_needed(message, workspace)
+        return unless message.user_id.start_with?('B') && @api_client
+
+        lookup_bot_name(workspace, message.user_id)
+      end
+
+      def lookup_bot_name(workspace, bot_id)
+        bots_api = Api::Bots.new(@api_client, workspace, on_debug: @on_debug)
+        name = bots_api.get_name(bot_id)
+        @cache.set_user(workspace.name, bot_id, name, persist: true) if name
+        name
+      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;', '>')
+      end
+
+      def format_files(message, lines, options, skip_first: false)
+        return if options[:no_files]
+
+        files = files_to_display(message.files, skip_first)
+        files.each { |file| lines << @output.blue("[File: #{file['name'] || 'file'}]") }
+      end
+
+      def files_to_display(files, skip_first)
+        return [] if files.empty?
+
+        skip_first ? (files[1..] || []) : files
+      end
+
+      def format_reactions(message, lines, workspace, options)
+        return if message.reactions.empty? || options[:no_reactions]
+
+        if options[:reaction_timestamps] && message.reactions.any?(&:timestamps?)
+          lines.concat(@reaction_formatter.format_with_timestamps(message.reactions, workspace, options))
+        else
+          lines << @reaction_formatter.format_summary(message.reactions, options)
+        end
+      end
+
+      def format_thread_indicator(message, lines, options)
+        return unless message.thread? && !options[:in_thread] && !options[:no_threads]
+
+        reply_text = message.reply_count == 1 ? '1 reply' : "#{message.reply_count} replies"
+        lines << @output.cyan("[#{reply_text}]")
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/{slack_cli → slk}/formatters/output.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Formatters
+    # Terminal output with ANSI color support
     class Output
       COLORS = {
         red: "\e[0;31m",
@@ -25,7 +26,7 @@ module SlackCli
         @quiet = quiet
       end
 
-      def puts(message = "")
+      def puts(message = '')
         @io.puts(message) unless @quiet
       end
 
@@ -34,15 +35,15 @@ module SlackCli
       end
 
       def error(message)
-        @err.puts(colorize("#{red("Error:")} #{message}"))
+        @err.puts(colorize("#{red('Error:')} #{message}"))
       end
 
       def warn(message)
-        @err.puts(colorize("#{yellow("Warning:")} #{message}")) unless @quiet
+        @err.puts(colorize("#{yellow('Warning:')} #{message}")) unless @quiet
       end
 
       def success(message)
-        puts(colorize("#{green("✓")} #{message}"))
+        puts(colorize("#{green('✓')} #{message}"))
       end
 
       def info(message)
@@ -52,7 +53,7 @@ module SlackCli
       def debug(message)
         return unless @verbose
 
-        @err.puts(colorize("#{gray("[debug]")} #{message}"))
+        @err.puts(colorize("#{gray('[debug]')} #{message}"))
       end
 
       # Color helpers

data/lib/slk/formatters/reaction_formatter.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Slk
+  module Formatters
+    # Formats reaction data for terminal display
+    class ReactionFormatter
+      def initialize(output:, emoji_replacer:, cache_store:)
+        @output = output
+        @emoji = emoji_replacer
+        @cache = cache_store
+      end
+
+      # Format reactions inline for simple display: " [2 👍, 1 ❤️]"
+      def format_inline(reactions, options = {})
+        parts = reactions.map do |r|
+          emoji = resolve_emoji(r.name, options)
+          "#{r.count} #{emoji}"
+        end
+        " [#{parts.join(', ')}]"
+      end
+
+      # Format reactions as a single line: "[2 👍  1 ❤️]"
+      def format_summary(reactions, options = {})
+        reaction_text = reactions.map do |r|
+          emoji = resolve_emoji(r.name, options)
+          "#{r.count} #{emoji}"
+        end.join('  ')
+
+        @output.yellow("[#{reaction_text}]")
+      end
+
+      # Format reactions with timestamps, one per line
+      def format_with_timestamps(reactions, workspace, options = {})
+        workspace_name = workspace&.name
+        lines = []
+
+        reactions.each do |reaction|
+          emoji = resolve_emoji(reaction.name, options)
+          user_strings = format_user_timestamps(reaction, workspace_name, options)
+          lines << @output.yellow("  ↳ #{emoji} #{user_strings.join(', ')}")
+        end
+
+        lines
+      end
+
+      private
+
+      def resolve_emoji(name, options)
+        if options[:no_emoji]
+          ":#{name}:"
+        else
+          @emoji.lookup_emoji(name) || ":#{name}:"
+        end
+      end
+
+      def format_user_timestamps(reaction, workspace_name, options)
+        reaction.users.map do |user_id|
+          username = resolve_user(user_id, workspace_name, options)
+          timestamp = reaction.timestamp_for(user_id)
+
+          if timestamp
+            time_str = format_time(timestamp)
+            "#{username} (#{time_str})"
+          else
+            username
+          end
+        end
+      end
+
+      def resolve_user(user_id, workspace_name, options)
+        return user_id if options[:no_names]
+
+        if workspace_name
+          cached = @cache.get_user(workspace_name, user_id)
+          return cached if cached
+        end
+
+        user_id
+      end
+
+      def format_time(slack_timestamp)
+        time = Time.at(slack_timestamp.to_f)
+        time.strftime('%-I:%M %p') # e.g., "2:45 PM"
+      end
+    end
+  end
+end

data/lib/{slack_cli → slk}/models/channel.rb

@@ -1,19 +1,20 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Models
     Channel = Data.define(:id, :name, :is_private, :is_im, :is_mpim, :is_archived) do
       def self.from_api(data)
         new(
-          id: data["id"],
-          name: data["name"] || data["name_normalized"],
-          is_private: data["is_private"] || false,
-          is_im: data["is_im"] || false,
-          is_mpim: data["is_mpim"] || false,
-          is_archived: data["is_archived"] || false
+          id: data['id'],
+          name: data['name'] || data['name_normalized'],
+          is_private: data['is_private'] || false,
+          is_im: data['is_im'] || false,
+          is_mpim: data['is_mpim'] || false,
+          is_archived: data['is_archived'] || false
         )
       end
 
+      # rubocop:disable Metrics/ParameterLists
       def initialize(id:, name: nil, is_private: false, is_im: false, is_mpim: false, is_archived: false)
         super(
           id: id.to_s.freeze,
@@ -24,6 +25,7 @@ module SlackCli
           is_archived: is_archived
         )
       end
+      # rubocop:enable Metrics/ParameterLists
 
       def dm?
         is_im || is_mpim
@@ -37,9 +39,9 @@ module SlackCli
         return name if name
 
         case id[0]
-        when "C" then "#channel"
-        when "G" then "#private"
-        when "D" then "DM"
+        when 'C' then '#channel'
+        when 'G' then '#private'
+        when 'D' then 'DM'
         else id
         end
       end