slk 0.10.0 → 0.11.0

data/lib/slk/services/sent_conversations.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+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.
+          [BigDecimal(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 = (BigDecimal(window.last.ts) + @after_seconds).to_s('F')
+        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,73 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+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(BigDecimal(value).to_r)
+      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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Slk
-  VERSION = '0.10.0'
+  VERSION = '0.11.0'
 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,7 @@ 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 :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.0
 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,6 +135,7 @@ 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/error_logger.rb
 - lib/slk/support/help_formatter.rb
@@ -164,7 +171,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: []