slk 0.10.0 → 0.11.1

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

data/lib/slk/services/sent_conversations.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Expands indexed from:me hits into bounded channel windows, full DM
+    # histories and full threads. Search is the seed, not the context source.
+    # rubocop:disable Metrics/ClassLength
+    class SentConversations
+      Conversation = Data.define(:workspace, :channel_id, :channel_name, :channel_type, :type, :thread_ts,
+                                 :first_sent_ts, :messages, :last_speaker_is_me, :dropped_messages,
+                                 :self_user_id, :self_username)
+      DEFAULT_BEFORE = 5
+      DEFAULT_AFTER_MINUTES = 30
+      DEFAULT_MAX = 200
+
+      # A date span plus three independent window/output limits.
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(runner:, start_date:, end_date:, before: DEFAULT_BEFORE,
+                     after_minutes: DEFAULT_AFTER_MINUTES, max: DEFAULT_MAX)
+        @runner = runner
+        @start_date = start_date
+        @end_date = end_date
+        @before = before
+        @after_seconds = after_minutes * 60
+        @max = max
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def collect(entries)
+        @self_ids = entries.to_h { |workspace, result| [workspace.name, self_id(workspace, result)] }
+        groups = entries.group_by { |workspace, result| [workspace.name, result.channel_id] }
+        conversations = groups.flat_map { |_key, group| collect_channel(group) }
+        # A thread parent can also appear in a channel window / DM history.
+        # Thread owns the message so the same (channel, ts) is never repeated.
+        ordered_conversations(deduplicate(conversations))
+      end
+
+      private
+
+      def ordered_conversations(conversations)
+        conversations.sort_by do |conversation|
+          # Keep Slack's fractional timestamp precise; identity breaks ties regardless of input order or platform.
+          [Support::DecimalTimestamp.parse(conversation.first_sent_ts), conversation.workspace.name.to_s,
+           conversation.channel_id.to_s, conversation.thread_ts.to_s]
+        end
+      end
+
+      # Partitioning a channel needs both the reply roots and unthreaded hits.
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def collect_channel(group)
+        workspace, seed = group.first
+        hits = group.map(&:last)
+        @self_id = @self_ids[workspace.name]
+        @api = @runner.conversations_api(workspace.name)
+        threaded = hits.select { |hit| hit.thread_ts && hit.thread_ts != hit.ts }.group_by(&:thread_ts)
+        ordinary = hits.reject { |hit| threaded.key?(hit.thread_ts) || threaded.key?(hit.ts) }
+        threads = threaded.map do |root, results|
+          parent_hit = hits.find { |hit| hit.ts == root }
+          thread_hits = parent_hit ? [parent_hit, *results] : results
+          thread_conversation(workspace, seed, root, thread_hits)
+        end
+        spans = if seed.dm?
+                  ordinary.empty? ? [] : [dm_conversation(workspace, seed, ordinary)]
+                else
+                  channel_conversations(workspace, seed, ordinary)
+                end
+        threads + spans
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+      def self_id(workspace, result)
+        return result.user_id if result.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_conversation(workspace, seed, root, hits)
+        raw = thread_messages(seed.channel_id, root)
+        build(workspace, seed, 'thread', root, hits, raw)
+      end
+
+      def dm_conversation(workspace, seed, hits)
+        start_at = @start_date.to_time.to_i
+        # Slack's latest is exclusive; +1 includes messages in this second.
+        end_at = [(@end_date + 1).to_time.to_i, Time.now.to_i + 1].min
+        raw = page_through(:history, channel: seed.channel_id, oldest: start_at.to_s, latest: end_at.to_s)
+        build(workspace, seed, seed.channel_type, nil, hits, raw, expand_threads: true)
+      end
+
+      def channel_conversations(workspace, seed, hits)
+        merge_windows(hits).map { |window| channel_window(workspace, seed, window) }
+      end
+
+      def channel_window(workspace, seed, window)
+        preceding = preceding_messages(seed.channel_id, window.first.ts)
+        following = following_messages(seed.channel_id, window)
+        build(workspace, seed, 'channel', nil, window, preceding + following, expand_threads: true)
+      end
+
+      def preceding_messages(channel_id, timestamp)
+        return [] if @before.zero?
+
+        @api.history(channel: channel_id, latest: timestamp, limit: @before).fetch('messages', [])
+      end
+
+      def following_messages(channel_id, window)
+        return [] if @after_seconds.zero?
+
+        end_at = Support::DecimalTimestamp.add(window.last.ts, @after_seconds)
+        page_through(:history, channel: channel_id, oldest: window.first.ts, latest: end_at, inclusive: true)
+      end
+
+      def merge_windows(hits)
+        hits.sort_by { |hit| hit.ts.to_f }.each_with_object([]) do |hit, windows|
+          if windows.any? && hit.ts.to_f <= windows.last.last.ts.to_f + @after_seconds
+            windows.last << hit
+          else
+            windows << [hit]
+          end
+        end
+      end
+
+      def thread_messages(channel_id, root)
+        page_through(:replies, channel: channel_id, timestamp: root)
+      end
+
+      # Cursor follow-up is necessary even when the first page is full.
+      # rubocop:disable Metrics/MethodLength
+      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']
+
+          next_cursor = response.dig('response_metadata', 'next_cursor').to_s
+          if next_cursor.empty? || next_cursor == cursor
+            raise ApiError, "conversations.#{endpoint} has_more without a new cursor"
+          end
+
+          cursor = next_cursor
+        end
+        messages
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # Keep the search hits as a fallback at Slack's exclusive history bounds.
+      # rubocop:disable Metrics/ParameterLists
+      def build(workspace, seed, type, root, hits, raw, expand_threads: false)
+        # Search's own hits ensure an indexed sent message cannot disappear just
+        # because history omits thread replies or returns a window boundary.
+        raw += hits.map { |hit| search_message(hit) }
+        raw = expand_own_threads(raw, seed, hits) if expand_threads
+        messages = normalize(raw, seed.channel_id)
+        last_is_me = messages.last&.user_id == @self_id
+        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: hits.first.ts,
+                         messages: messages, last_speaker_is_me: last_is_me, dropped_messages: 0,
+                         self_user_id: @self_id, self_username: hits.first.username)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def search_message(hit)
+        { 'ts' => hit.ts, 'user' => @self_id, 'username' => hit.username, 'text' => hit.text,
+          'thread_ts' => hit.thread_ts, 'reply_count' => hit.reply_count }
+      end
+
+      def expand_own_threads(raw, seed, hits)
+        own_roots(raw, seed, hits).each { |root| raw.concat(thread_messages(seed.channel_id, root)) }
+        raw
+      end
+
+      def own_roots(raw, seed, hits)
+        # Five preceding channel messages may include an old post of ours;
+        # don't expand its unrelated thread into today's conversation.
+        earliest = seed.dm? ? @start_date.to_time.to_i : hits.first.ts.to_f
+        raw.filter_map { |message| message['ts'] if own_thread_root?(message, earliest) }.uniq
+      end
+
+      def own_thread_root?(message, earliest)
+        message['user'] == @self_id && message['reply_count'].to_i.positive? &&
+          message['ts'].to_f >= earliest
+      end
+
+      def normalize(raw, channel_id)
+        raw.select { |message| readable?(message) }
+           .uniq { |message| message['ts'] }
+           .sort_by { |message| message['ts'].to_f }
+           .map { |message| Models::Message.from_api(message, channel_id: channel_id) }
+      end
+
+      def readable?(message)
+        message['ts'] && (message['user'] || message['bot_id'] || message['username'])
+      end
+
+      def deduplicate(conversations)
+        seen = {}
+        conversations.filter_map { |conversation| unique_conversation(conversation, seen) }
+      end
+
+      # Global dedupe happens before --max so a duplicate cannot consume a slot.
+      # rubocop:disable Metrics/AbcSize
+      def unique_conversation(conversation, seen)
+        key = [conversation.workspace.name, conversation.channel_id]
+        unique = conversation.messages.reject { |message| seen[[*key, message.ts]] }
+        return if unique.empty?
+
+        unique.each { |message| seen[[*key, message.ts]] = true }
+        kept = @max.zero? ? unique : unique.last(@max)
+        conversation.with(messages: kept, dropped_messages: unique.size - kept.size,
+                          last_speaker_is_me: unique.last.user_id == @self_ids[conversation.workspace.name])
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/slk/support/check_in_time.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'time'
+
+module Slk
+  module Support
+    # A stateless, exact timestamp for sent-conversation change detection.
+    class CheckInTime
+      RELATIVE = /\A(\d+)([mhd])\z/i
+      CLOCK = /\A(\d{1,2}):(\d{2})\z/
+      EPOCH = /\A\d{9,12}(?:\.\d{1,6})?\z/
+      ISO = /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2})?(?:Z|[+-]\d{2}:\d{2})?\z/
+
+      def self.parse(value, now: Time.now)
+        time = case value
+               when RELATIVE then relative(Regexp.last_match, now)
+               when CLOCK then clock(Regexp.last_match, now)
+               when EPOCH then epoch_time(value)
+               when ISO then iso_time(value)
+               else raise UsageError, 'Invalid --changed-since time. Use H:MM or HH:MM, ISO, epoch, 90m, 2h, or 1d.'
+               end
+        raise UsageError, '--changed-since must not be in the future.' if time > now
+
+        time
+      end
+
+      def self.timestamp(time)
+        format('%<seconds>d.%<micros>06d', seconds: time.to_i, micros: time.usec)
+      end
+
+      def self.epoch_time(value)
+        Time.at(DecimalTimestamp.parse(value))
+      rescue ArgumentError
+        raise UsageError, "Invalid --changed-since time: #{value.inspect}."
+      end
+
+      def self.iso_time(value)
+        Date.iso8601(value[0, 10])
+        with_seconds = value.sub(/(T\d{2}:\d{2})(?=Z|[+-]\d{2}:\d{2}|\z)/, '\\1:00')
+        Time.iso8601(with_seconds)
+      rescue ArgumentError
+        raise UsageError, "Invalid --changed-since time: #{value.inspect}."
+      end
+
+      def self.relative(match, now)
+        amount = match[1].to_i
+        raise UsageError, '--changed-since duration must be positive.' if amount.zero?
+
+        seconds = { 'm' => 60, 'h' => 3600, 'd' => 86_400 }.fetch(match[2].downcase)
+        now - (amount * seconds)
+      end
+
+      def self.clock(match, now)
+        hour, minute = match.captures.map(&:to_i)
+        raise UsageError, 'Invalid --changed-since clock time.' unless hour < 24 && minute < 60
+
+        day = now.to_date
+        time = local_clock(day, hour, minute)
+        return time if time <= now
+
+        local_clock(day - 1, hour, minute)
+      end
+
+      def self.local_clock(day, hour, minute)
+        Time.local(day.year, day.month, day.day, hour, minute)
+      rescue ArgumentError
+        raise UsageError, 'Invalid --changed-since clock time.'
+      end
+    end
+  end
+end

data/lib/slk/support/decimal_timestamp.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Slk
+  module Support
+    # Exact decimal arithmetic for Slack timestamps without an optional gem.
+    module DecimalTimestamp
+      def self.parse(value)
+        Rational(value.to_s)
+      end
+
+      def self.add(timestamp, offset)
+        decimal(parse(timestamp) + parse(offset))
+      end
+
+      def self.decimal(value)
+        twos, remaining = factor(value.denominator, 2)
+        fives, remaining = factor(remaining, 5)
+        raise ArgumentError, 'Timestamp must have a finite decimal representation' unless remaining == 1
+
+        places = [twos, fives].max
+        scaled = value.numerator * ((10**places) / value.denominator)
+        format_digits(scaled, places)
+      end
+
+      def self.format_digits(scaled, places)
+        digits = scaled.abs.to_s.rjust(places + 1, '0')
+        sign = scaled.negative? ? '-' : ''
+        return "#{sign}#{digits}.0" if places.zero?
+
+        "#{sign}#{digits[0...-places]}.#{digits[-places..]}"
+      end
+      private_class_method :format_digits
+
+      def self.factor(number, divisor)
+        count = 0
+        while (number % divisor).zero?
+          number /= divisor
+          count += 1
+        end
+        [count, number]
+      end
+      private_class_method :factor
+    end
+  end
+end

data/lib/slk/version.rb

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

data/lib/slk.rb

@@ -113,6 +113,10 @@ module Slk
     autoload :DeactivationScanner, 'slk/services/deactivation_scanner'
     autoload :StartDateLookup, 'slk/services/start_date_lookup'
     autoload :StartDateField, 'slk/services/start_date_field'
+    autoload :SearchPages, 'slk/services/search_pages'
+    autoload :SentConversations, 'slk/services/sent_conversations'
+    autoload :SentChanges, 'slk/services/sent_changes'
+    autoload :SentChannelLabel, 'slk/services/sent_channel_label'
   end
 
   # Output formatters for messages, durations, and emoji
@@ -130,6 +134,7 @@ module Slk
     autoload :AttachmentFormatter, 'slk/formatters/attachment_formatter'
     autoload :BlockFormatter, 'slk/formatters/block_formatter'
     autoload :SearchFormatter, 'slk/formatters/search_formatter'
+    autoload :SentFormatter, 'slk/formatters/sent_formatter'
     autoload :SavedItemFormatter, 'slk/formatters/saved_item_formatter'
     autoload :TextProcessor, 'slk/formatters/text_processor'
     autoload :ProfileFormatter, 'slk/formatters/profile_formatter'
@@ -152,6 +157,7 @@ module Slk
     autoload :Catchup, 'slk/commands/catchup'
     autoload :Activity, 'slk/commands/activity'
     autoload :Search, 'slk/commands/search'
+    autoload :Sent, 'slk/commands/sent'
     autoload :Preset, 'slk/commands/preset'
     autoload :Workspaces, 'slk/commands/workspaces'
     autoload :Cache, 'slk/commands/cache'
@@ -193,6 +199,8 @@ module Slk
     autoload :TextWrapper, 'slk/support/text_wrapper'
     autoload :InteractivePrompt, 'slk/support/interactive_prompt'
     autoload :DateParser, 'slk/support/date_parser'
+    autoload :CheckInTime, 'slk/support/check_in_time'
+    autoload :DecimalTimestamp, 'slk/support/decimal_timestamp'
     autoload :TimeParser, 'slk/support/time_parser'
     autoload :TimeRangeParser, 'slk/support/time_range_parser'
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slk
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.1
 platform: ruby
 authors:
 - Eric Boehs
@@ -56,6 +56,7 @@ files:
 - lib/slk/commands/presence.rb
 - lib/slk/commands/preset.rb
 - lib/slk/commands/search.rb
+- lib/slk/commands/sent.rb
 - lib/slk/commands/ssh_key_manager.rb
 - lib/slk/commands/status.rb
 - lib/slk/commands/thread.rb
@@ -82,6 +83,7 @@ files:
 - lib/slk/formatters/reaction_formatter.rb
 - lib/slk/formatters/saved_item_formatter.rb
 - lib/slk/formatters/search_formatter.rb
+- lib/slk/formatters/sent_formatter.rb
 - lib/slk/formatters/text_processor.rb
 - lib/slk/models/channel.rb
 - lib/slk/models/deactivation.rb
@@ -117,6 +119,10 @@ files:
 - lib/slk/services/profile_builder.rb
 - lib/slk/services/profile_resolver.rb
 - lib/slk/services/reaction_enricher.rb
+- lib/slk/services/search_pages.rb
+- lib/slk/services/sent_changes.rb
+- lib/slk/services/sent_channel_label.rb
+- lib/slk/services/sent_conversations.rb
 - lib/slk/services/setup_wizard.rb
 - lib/slk/services/start_date_field.rb
 - lib/slk/services/start_date_lookup.rb
@@ -129,7 +135,9 @@ files:
 - lib/slk/services/user_matcher.rb
 - lib/slk/services/user_picker.rb
 - lib/slk/services/who_target_resolver.rb
+- lib/slk/support/check_in_time.rb
 - lib/slk/support/date_parser.rb
+- lib/slk/support/decimal_timestamp.rb
 - lib/slk/support/error_logger.rb
 - lib/slk/support/help_formatter.rb
 - lib/slk/support/inline_images.rb
@@ -164,7 +172,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: A command-line interface for Slack
 test_files: []