slk 0.10.0 → 0.11.0

data/lib/slk/formatters/sent_formatter.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Slk
+  module Formatters
+    # Renders expanded sent-message conversations for people and scripts.
+    # rubocop:disable Metrics/ClassLength
+    class SentFormatter
+      def initialize(runner:, options: {})
+        @runner = runner
+        @options = options
+        @names = {}
+      end
+
+      def display(conversations, start_date:, end_date:, json: false)
+        if json
+          @runner.output.puts(JSON.pretty_generate(payload(conversations, start_date, end_date)))
+        else
+          display_text(conversations)
+        end
+      end
+
+      def display_changes(changes, changed_since:, lookback_days:, json: false)
+        if json
+          @runner.output.puts(JSON.pretty_generate(changes_payload(changes, changed_since, lookback_days)))
+        else
+          display_changed_text(changes)
+        end
+      end
+
+      private
+
+      def payload(conversations, start_date, end_date)
+        { date: start_date == end_date ? start_date.iso8601 : nil,
+          range: start_date == end_date ? nil : { since: start_date.iso8601, through: end_date.iso8601 },
+          conversations: conversations.map { |conversation| json_conversation(conversation) } }
+      end
+
+      def changes_payload(changes, since, days)
+        { date: nil, range: { since: (Date.today - days + 1).iso8601, through: Date.today.iso8601 },
+          changed_since: { iso: since.iso8601(since.usec.zero? ? 0 : 6),
+                           ts: Support::CheckInTime.timestamp(since) },
+          lookback_days: days, conversations: changes.map { |change| json_change(change) } }
+      end
+
+      def json_change(change)
+        conversation = change.conversation
+        json_conversation(conversation).merge(
+          new_count: change.new_count, new_from_others: change.new_from_others,
+          messages: conversation.messages.map do |message|
+            json_message(message, conversation).merge(new: change.new_timestamps.include?(message.ts))
+          end
+        )
+      end
+
+      def json_conversation(conversation)
+        { workspace: conversation.workspace.name, channel_id: conversation.channel_id,
+          channel_name: conversation.channel_name, channel_label: channel_label(conversation), type: conversation.type,
+          thread_ts: conversation.thread_ts, last_speaker_is_me: conversation.last_speaker_is_me,
+          dropped_messages: conversation.dropped_messages,
+          messages: conversation.messages.map { |message| json_message(message, conversation) } }
+      end
+
+      def json_message(message, conversation)
+        { ts: message.ts, user: message.user_id, user_name: user_name(message, conversation.workspace),
+          text: message.text, mine: mine?(message, conversation), thread_ts: message.thread_ts }
+      end
+
+      def user_name(message, workspace)
+        key = [workspace.name, message.user_id]
+        @names[key] ||= message.embedded_username || @runner.cache_store.get_user(workspace.name, message.user_id) ||
+                        Services::UserLookup.new(cache_store: @runner.cache_store, workspace: workspace,
+                                                 api_client: @runner.api_client).resolve_name_or_bot(message.user_id) ||
+                        message.user_id
+      end
+
+      def display_text(conversations)
+        return @runner.output.puts 'No sent conversations found.' if conversations.empty?
+
+        display_items(conversations) { |conversation| display_conversation(conversation) }
+      end
+
+      def display_conversation(conversation)
+        display_header(conversation)
+        display_messages(conversation.messages, conversation)
+      end
+
+      def display_items(items)
+        items.each_with_index do |item, index|
+          display_divider if index.positive?
+          yield item
+          @runner.output.puts
+        end
+      end
+
+      def display_divider
+        width = (@options[:width] || 32).clamp(1, 32)
+        @runner.output.puts @runner.output.gray('─' * width)
+        @runner.output.puts
+      end
+
+      def display_changed_text(changes)
+        return @runner.output.puts 'No changed sent conversations found.' if changes.empty?
+
+        display_items(changes) { |change| display_changed_conversation(change) }
+      end
+
+      def display_changed_conversation(change)
+        conversation = change.conversation
+        display_header(conversation, summary: "#{change.new_count} new (#{change.new_from_others} from others)")
+        context, fresh = conversation.messages.partition { |message| !change.new_timestamps.include?(message.ts) }
+        display_messages(context, conversation, context: true)
+        display_messages(fresh, conversation, parent_timestamps: context.map(&:ts))
+      end
+
+      def display_messages(messages, conversation, context: false, parent_timestamps: [])
+        replies = replies_by_parent(messages)
+        messages.each do |message|
+          next if replies.key?(message.thread_ts) && message.reply?
+
+          display_message(message, conversation,
+                          orphan: message.reply? && !parent_timestamps.include?(message.thread_ts), context: context)
+          replies.fetch(message.ts, []).each { |reply| display_message(reply, conversation, context: context) }
+        end
+      end
+
+      def replies_by_parent(messages)
+        timestamps = messages.to_h { |message| [message.ts, true] }
+        messages.select { |message| message.reply? && timestamps.key?(message.thread_ts) }
+                .group_by(&:thread_ts)
+      end
+
+      # Header combines the resolved destination and optional thread ID.
+      def display_header(conversation, summary: nil)
+        @runner.output.puts wrap_heading(heading_for(conversation, summary))
+        return unless conversation.dropped_messages.positive?
+
+        @runner.output.puts "(#{conversation.dropped_messages} older messages omitted by --max)"
+      end
+
+      def heading_for(conversation, summary)
+        heading = "[#{conversation.workspace.name}] #{channel_label(conversation)}"
+        heading += " (thread: #{conversation.thread_ts})" if conversation.type == 'thread'
+        heading += " — #{summary}" if summary
+        heading
+      end
+
+      def display_message(message, conversation, orphan: false, context: false)
+        display_orphan_reference(message, context) if orphan
+        prefix = message.reply? ? '    ↳ ' : ''
+        prefix = "· #{prefix}" if context
+        line = "#{prefix}#{formatted_message(message, conversation, prefix)}"
+        @runner.output.puts(context ? @runner.output.gray(line) : line)
+      end
+
+      def display_orphan_reference(message, context)
+        line = "    (thread #{message.thread_ts})"
+        line = "· #{line}" if context
+        @runner.output.puts(context ? @runner.output.gray(line) : line)
+      end
+
+      def formatted_message(message, conversation, prefix)
+        indent = ' ' * Support::TextWrapper.visible_length(prefix)
+        options = @options.dup
+        options[:width] -= indent.length if options[:width]
+        formatted = @runner.message_formatter.format(message, workspace: conversation.workspace, options: options)
+        indent.empty? ? formatted : formatted.gsub("\n", "\n#{indent}")
+      end
+
+      def wrap_heading(heading)
+        width = @options[:width]
+        return heading unless width && width > 2
+
+        Support::TextWrapper.wrap(heading, width, width - 2).gsub("\n", "\n  ")
+      end
+
+      def channel_label(conversation)
+        @runner.sent_channel_label.label(
+          workspace: conversation.workspace, type: conversation.channel_type,
+          name: conversation.channel_name, channel_id: conversation.channel_id,
+          self_user_id: conversation.self_user_id, self_username: conversation.self_username
+        )
+      end
+
+      def mine?(message, conversation)
+        # The search result provides the authenticated sender's user ID. It
+        # remains attached to each conversation even if the first message is
+        # an older parent from someone else.
+        message.user_id == conversation.self_user_id
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/slk/models/search_result.rb

@@ -13,6 +13,7 @@ module Slk
       :channel_name,
       :channel_type,
       :thread_ts,
+      :reply_count,
       :permalink,
       :files
     ) do
@@ -32,6 +33,7 @@ module Slk
           channel_name: channel['name'],
           channel_type: determine_channel_type(channel),
           thread_ts: extract_thread_ts(match),
+          reply_count: match['reply_count'].to_i,
           permalink: match['permalink'],
           files: extract_files(match)
         }

data/lib/slk/runner.rb

@@ -159,6 +159,10 @@ module Slk
       )
     end
 
+    def sent_channel_label
+      @sent_channel_label ||= Services::SentChannelLabel.new(runner: self)
+    end
+
     # Logging
     def log_error(error)
       Support::ErrorLogger.log(error)

data/lib/slk/services/search_pages.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Walks search.messages pages without silently dropping results at Slack's
+    # 100-result page boundary. A limit caps results per workspace; nil fetches all.
+    class SearchPages
+      def initialize(search_api)
+        @search_api = search_api
+      end
+
+      # The loop tracks both the API page and the requested result cap.
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def fetch(query:, limit: nil, page: 1, sort_dir: 'desc')
+        results = []
+        first_pagination = nil
+        matches = []
+        current = page
+        count = limit ? [limit, 100].min : 100
+
+        loop do
+          # Keep count fixed: Slack computes page offsets from count. Changing
+          # 100 to 50 for the last page would repeat rows from the first page.
+          response = @search_api.messages(query: query, count: count, page: current, sort_dir: sort_dir)
+          messages = response.fetch('messages', {})
+          matches = messages.fetch('matches', [])
+          pagination = messages.fetch('pagination', {})
+          first_pagination ||= pagination
+          remaining = limit ? limit - results.length : matches.length
+          results.concat(matches.first(remaining).map { |match| Models::SearchResult.from_api(match) })
+          break if matches.empty?
+
+          if !pagination['page_count'] && matches.length >= count
+            raise ApiError, 'Search response omitted pagination; cannot guarantee complete results'
+          end
+          break if limit && results.length >= limit
+          break unless pagination['page_count'] && current < pagination['page_count'].to_i
+
+          current += 1
+        end
+
+        { results: results, pagination: first_pagination || {},
+          truncated: truncated?(first_pagination, page, current, results, matches, limit) }
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+      private
+
+      # A short limit can cut off a page even when Slack omits total_count.
+      # The page offset and last batch are needed when total_count is missing.
+      # rubocop:disable Metrics/ParameterLists
+      def truncated?(pagination, page, current, results, matches, limit)
+        return false unless limit
+
+        offset = (page - 1) * [limit, 100].min
+        total = pagination['total_count']
+        return total.to_i > offset + results.length if total
+
+        matches.length > [limit - ((current - page) * [limit, 100].min), 0].max ||
+          pagination['page_count'].to_i > current
+      end
+      # rubocop:enable Metrics/ParameterLists
+    end
+  end
+end

data/lib/slk/services/sent_changes.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Slk
+  module Services
+    # Stateless diff of watched sent conversations. Search discovers what to
+    # watch; exact-ts history/replies determine what actually changed.
+    # Orchestration spans workspace watch sets, thread diffs and output windows.
+    # rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+    class SentChanges
+      Change = Data.define(:conversation, :new_timestamps, :new_count, :new_from_others)
+      Conversation = SentConversations::Conversation
+      OPTIONAL_SUBSCRIPTION_ERRORS = %i[missing_scope not_allowed_token_type unknown_method].freeze
+
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(runner:, since:, context: 2, max: 200, before: 5, after_minutes: 30)
+        @runner = runner
+        @since = since
+        @since_ts = Support::CheckInTime.timestamp(since)
+        @context = context
+        @max = max
+        @before = before
+        @after_minutes = after_minutes
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def collect(entries, workspaces:)
+        groups = entries.group_by { |workspace, hit| [workspace.name, hit.channel_id] }
+        changes = workspaces.flat_map { |workspace| collect_workspace(workspace, groups) }
+        changes.sort_by do |change|
+          conversation = change.conversation
+          # Put the most recently active conversation last. Trailing identity
+          # keys make ties deterministic across platforms (including Windows).
+          [BigDecimal(conversation.messages.last.ts), conversation.workspace.name.to_s,
+           conversation.channel_id.to_s, conversation.thread_ts.to_s]
+        end
+      end
+
+      private
+
+      def collect_workspace(workspace, groups)
+        @workspace = workspace
+        @api = @runner.conversations_api(workspace.name)
+        @self_id = self_id(workspace, groups)
+        local = groups.select { |(name, _id), _hits| name == workspace.name }
+        changed_threads = local.flat_map { |(_name, _id), entries| thread_changes(entries.map(&:last)) }
+        changed_threads.concat(subscribed_changes(changed_threads, local))
+        claimed = changed_threads.flat_map { |change| change.conversation.messages.map(&:ts) }.to_h { |ts| [ts, true] }
+        other = local.flat_map do |(_name, _id), entries|
+          hits = entries.map(&:last)
+          hits.first.dm? ? dm_changes(hits, claimed) : channel_changes(hits, claimed)
+        end
+        changed_threads + other
+      end
+
+      def self_id(workspace, groups)
+        entries = groups.find { |(name, _id), rows| name == workspace.name && rows.any? }&.last
+        hit = entries&.first&.last
+        return hit.user_id if hit&.user_id.to_s.match?(/\A[UW][A-Z0-9]+\z/i)
+
+        cached = @runner.cache_store.get_meta(workspace.name, 'self_user_id')
+        return cached if cached
+
+        id = @runner.client_api(workspace.name).auth_test['user_id']
+        raise ApiError, "Cannot identify sender in #{workspace.name}" unless id
+
+        @runner.cache_store.set_meta(workspace.name, 'self_user_id', id)
+        id
+      end
+
+      def thread_changes(hits)
+        metadata = root_metadata(hits)
+        hits.map { |hit| [hit.thread_ts || hit.ts, hit] }.uniq(&:first).filter_map do |root, seed|
+          parent = metadata[root]
+          next if parent && !thread_active?(parent)
+
+          thread_change(seed, root, full_first: parent && parent['latest_reply'])
+        end
+      end
+
+      # Fetch the watched top-level parents in one paginated history scan per
+      # channel. Search often omits reply_count; history has latest_reply.
+      def root_metadata(hits)
+        roots = hits.select { |hit| top_level?(hit) }.map(&:ts).uniq
+        return {} if roots.empty?
+
+        wanted = roots.to_h { |root| [root, true] }
+        found = {}
+        cursor = nil
+        loop do
+          response = @api.history(channel: hits.first.channel_id,
+                                  oldest: roots.min_by { |root| BigDecimal(root) }, inclusive: true,
+                                  limit: 200, cursor: cursor)
+          response.fetch('messages', []).each do |message|
+            found[message['ts']] = message if wanted[message['ts']]
+          end
+          break if found.size == wanted.size || !response['has_more']
+
+          cursor = next_cursor!(response, cursor, :history)
+        end
+        found
+      end
+
+      def thread_active?(parent)
+        latest = parent['latest_reply']
+        return newer?(latest) if latest
+
+        parent['reply_count'].to_i.positive?
+      end
+
+      def thread_change(seed, root, require_participation: false, full_first: false)
+        full = page_through(:replies, channel: seed.channel_id, timestamp: root) if full_first
+        recent = full || page_through(:replies, channel: seed.channel_id, timestamp: root, oldest: @since_ts)
+        fresh = after_cutoff(recent)
+        # A new top-level post without replies belongs in its channel/DM
+        # window, not in a synthetic one-message thread.
+        return if fresh.none? { |row| row['ts'] != root }
+
+        full ||= page_through(:replies, channel: seed.channel_id, timestamp: root)
+        return if require_participation && full.none? { |row| row['user'] == @self_id }
+
+        context = previous_messages(full, parent_ts: root)
+        change(seed, 'thread', root, fresh, context)
+      rescue ApiError => e
+        raise unless e.code == :thread_not_found
+      end
+
+      # Slack's thread view exposes unread followed threads, not a complete
+      # subscriptions cursor. Union the first page, and verify participation.
+      def subscribed_changes(existing, local)
+        response = subscribed_view
+        return [] unless response
+
+        known = existing.map { |change| [change.conversation.channel_id, change.conversation.thread_ts] }
+        known.concat(local.flat_map do |(_name, channel), entries|
+          entries.map { |_workspace, hit| [channel, hit.thread_ts || hit.ts] }
+        end)
+        response.fetch('threads', []).filter_map do |item|
+          root = item['root_msg'] || {}
+          channel = root['channel']
+          timestamp = root['thread_ts'] || root['ts']
+          next unless channel && timestamp && !known.include?([channel, timestamp])
+
+          seed = subscription_seed(channel, timestamp, root)
+          next unless seed
+
+          thread_change(seed, timestamp, require_participation: true)
+        end
+      end
+
+      def subscribed_view
+        @runner.threads_api(@workspace.name).get_view(limit: 100)
+      rescue ApiError => e
+        # Only unsupported/unauthorized-to-use subscription views are optional.
+        # Network, rate-limit and other failures must not look like a clean check-in.
+        raise unless OPTIONAL_SUBSCRIPTION_ERRORS.include?(e.code)
+
+        nil
+      end
+
+      def subscription_seed(channel, timestamp, root)
+        info = @api.info(channel: channel).fetch('channel', {})
+        type = if info['is_im']
+                 'im'
+               elsif info['is_mpim']
+                 'mpim'
+               else
+                 'channel'
+               end
+        name = type == 'im' ? info['user'] : info['name']
+        return unless name
+
+        Models::SearchResult.new(ts: timestamp, user_id: @self_id, username: nil, text: root['text'].to_s,
+                                 channel_id: channel, channel_name: name, channel_type: type,
+                                 thread_ts: timestamp, reply_count: 0, permalink: nil, files: [])
+      end
+
+      def dm_changes(hits, claimed)
+        seed = hits.first
+        probe = @api.history(channel: seed.channel_id, oldest: @since_ts, limit: 1)
+        recent = if probe['has_more']
+                   page_through(:history, channel: seed.channel_id, oldest: @since_ts)
+                 else
+                   probe.fetch('messages', [])
+                 end
+        fresh = after_cutoff(recent).reject { |row| claimed[row['ts']] }
+        return [] if fresh.empty?
+
+        earlier = if @context.zero?
+                    []
+                  else
+                    @api.history(channel: seed.channel_id, latest: @since_ts,
+                                 inclusive: true, limit: @context).fetch('messages', [])
+                  end
+        context = previous_messages(earlier)
+        [change(seed, seed.channel_type, nil, fresh, context)]
+      end
+
+      def channel_changes(hits, claimed)
+        recent = hits.select { |hit| top_level?(hit) && newer?(hit.ts) }
+        return [] if recent.empty?
+
+        windows = SentConversations.new(runner: @runner, start_date: @since.to_date, end_date: Date.today,
+                                        before: @before, after_minutes: @after_minutes, max: 0).collect(
+                                          recent.map { |hit| [@workspace, hit] }
+                                        )
+        own_timestamps = recent.to_h { |hit| [hit.ts, true] }
+        windows.filter_map do |window|
+          next unless window.type == 'channel'
+
+          fresh = window.messages.select { |msg| own_timestamps[msg.ts] && !claimed[msg.ts] }
+          next if fresh.empty?
+
+          context = previous_messages(window.messages)
+          change(hits.first, 'channel', nil, fresh, context)
+        end
+      end
+
+      def top_level?(hit)
+        hit.thread_ts.nil? || hit.thread_ts == hit.ts
+      end
+
+      def previous_messages(raw, parent_ts: nil)
+        older = raw.select { |row| row_timestamp(row) && !newer?(row_timestamp(row)) }
+        older = older.last(@context) unless @context.zero?
+        older = [] if @context.zero?
+        return older unless parent_ts && @context.positive?
+
+        parent = raw.find { |row| row_timestamp(row) == parent_ts }
+        parent && !newer?(parent_ts) ? ([parent] + older.reject { |row| row == parent }.last(@context - 1)) : older
+      end
+
+      # Counts and last speaker are calculated before --max hides any output.
+      def change(seed, type, root, fresh, context)
+        messages = normalize(context + fresh, seed.channel_id)
+        new_ts = fresh.map { |row| row_timestamp(row) }.uniq
+        new_messages = messages.select { |message| new_ts.include?(message.ts) }
+        return if new_messages.empty?
+
+        kept = @max.zero? ? messages : messages.last(@max)
+        conversation = Conversation.new(
+          workspace: @workspace, channel_id: seed.channel_id, channel_name: seed.channel_name,
+          channel_type: seed.channel_type, type: type, thread_ts: root, first_sent_ts: seed.ts,
+          messages: kept, last_speaker_is_me: new_messages.last.user_id == @self_id,
+          dropped_messages: messages.size - kept.size, self_user_id: @self_id,
+          self_username: seed.username
+        )
+        others = new_messages.count { |message| message.user_id != @self_id }
+        Change.new(conversation: conversation, new_timestamps: new_ts,
+                   new_count: new_messages.size, new_from_others: others)
+      end
+
+      def normalize(raw, channel_id)
+        raw.map { |row| row.is_a?(Models::Message) ? row : Models::Message.from_api(row, channel_id: channel_id) }
+           .uniq(&:ts).sort_by { |message| BigDecimal(message.ts) }
+      end
+
+      def after_cutoff(raw)
+        raw.select { |row| row['ts'] && newer?(row['ts']) && (row['user'] || row['bot_id'] || row['username']) }
+      end
+
+      def row_timestamp(row)
+        row.is_a?(Models::Message) ? row.ts : row['ts']
+      end
+
+      def newer?(timestamp)
+        BigDecimal(timestamp) > BigDecimal(@since_ts)
+      end
+
+      def page_through(endpoint, **params)
+        messages = []
+        cursor = nil
+        loop do
+          response = @api.public_send(endpoint, **params, limit: 200, cursor: cursor)
+          messages.concat(response.fetch('messages', []))
+          break unless response['has_more']
+
+          cursor = next_cursor!(response, cursor, endpoint)
+        end
+        messages
+      end
+
+      def next_cursor!(response, previous, endpoint)
+        cursor = response.dig('response_metadata', 'next_cursor').to_s
+        raise ApiError, "conversations.#{endpoint} has_more without a new cursor" if cursor.empty? || cursor == previous
+
+        cursor
+      end
+    end
+    # rubocop:enable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+  end
+end

data/lib/slk/services/sent_channel_label.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Resolves sent-conversation destinations while retaining raw channel IDs
+    # and names in JSON. Group DMs need member lookup: their Slack name is an
+    # opaque mpdm-* slug, not a user ID that MentionReplacer can resolve.
+    class SentChannelLabel
+      USER_ID_PATTERN = /\A[UW][A-Z0-9]+\z/
+
+      def initialize(runner:)
+        @runner = runner
+        @labels = {}
+      end
+
+      # rubocop:disable Metrics/ParameterLists
+      def label(workspace:, type:, name:, channel_id:, self_user_id: nil, self_username: nil)
+        key = [workspace.name, channel_id, self_user_id]
+        @labels[key] ||= if type == 'mpim'
+                           group_label(workspace, channel_id, name, self_user_id, self_username)
+                         else
+                           @runner.search_formatter.channel_label_for(type, name, workspace)
+                         end
+      end
+
+      # rubocop:enable Metrics/ParameterLists
+
+      private
+
+      def group_label(workspace, channel_id, name, self_user_id, self_username)
+        names = group_member_names(workspace, channel_id, self_user_id)
+        return "@#{names.join(', ')}" if names.any?
+
+        fallback_group_label(name, self_username)
+      rescue ApiError
+        fallback_group_label(name, self_username)
+      end
+
+      def group_member_names(workspace, channel_id, self_user_id)
+        members = @runner.conversations_api(workspace.name).info(channel: channel_id).dig('channel', 'members') || []
+        names = members.reject { |id| id == self_user_id }.map { |id| resolve_name(workspace, id) }
+        names.any? { |value| value.match?(USER_ID_PATTERN) } ? [] : names
+      end
+
+      def resolve_name(workspace, user_id)
+        Services::UserLookup.new(cache_store: @runner.cache_store, workspace: workspace,
+                                 api_client: @runner.api_client).resolve_name_or_bot(user_id) || user_id
+      end
+
+      def fallback_group_label(name, self_username)
+        handles = name.to_s.sub(/\Ampdm-/, '').sub(/-\d+\z/, '').split('--')
+        people = handles.reject { |handle| normalized_handle(handle) == normalized_handle(self_username) }
+        people = handles if people.empty?
+        "@#{people.map { |handle| pretty_handle(handle) }.join(', ')}"
+      end
+
+      def normalized_handle(handle)
+        handle.to_s.downcase.gsub(/[^a-z0-9]/, '')
+      end
+
+      def pretty_handle(handle)
+        handle.tr('._-', ' ').split.map(&:capitalize).join(' ')
+      end
+    end
+  end
+end