slk 0.9.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/models/tenure.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Slk
+  module Models
+    # How long someone was here: a start date from their Slack profile and the
+    # date their account was deactivated.
+    #
+    # Both ends are softer than they look. The start date is whatever an admin
+    # typed into a custom profile field, and the end is the account's `updated`
+    # timestamp. Neither is a payroll record, so this rounds to whole months
+    # and refuses to imply a precision it does not have.
+    Tenure = Data.define(:started_on, :ended_on) do
+      # @param started [String, nil] ISO date from the profile field
+      # @param ended [Time, nil] deactivation time
+      def self.build(started, ended)
+        date = parse_date(started)
+        return nil unless date
+
+        new(started_on: date, ended_on: ended ? to_date(ended) : nil)
+      end
+
+      def self.parse_date(value)
+        text = value.to_s.strip
+        return nil unless /\A\d{4}-\d{2}-\d{2}\z/.match?(text)
+
+        Date.iso8601(text)
+      rescue Date::Error
+        nil
+      end
+
+      def self.to_date(time)
+        Date.new(time.year, time.month, time.day)
+      end
+
+      # Nil when the account is still active, or when the end predates the
+      # start — a start date typed in after the fact can land anywhere, and a
+      # negative tenure is a data entry error, not a fact about a person.
+      def months
+        return nil unless ended_on && ended_on >= started_on
+
+        ended_on.day < started_on.day ? month_span - 1 : month_span
+      end
+
+      def month_span
+        ((ended_on.year - started_on.year) * 12) + (ended_on.month - started_on.month)
+      end
+      private :month_span
+
+      # "6y 2mo", "11mo", "<1mo" — whole months only.
+      def to_s
+        total = months
+        return '' unless total
+        return '<1mo' if total.zero?
+
+        years, rest = total.divmod(12)
+        [years.positive? ? "#{years}y" : nil, rest.positive? ? "#{rest}mo" : nil].compact.join(' ')
+      end
+
+      # True when the length cannot be worked out: an active account, or an
+      # end date that predates the start.
+      def unknown? = months.nil?
+
+      def started = started_on.iso8601
+    end
+  end
+end

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/api_client.rb

@@ -232,7 +232,7 @@ module Slk
       end
 
       def parse_success_response(response)
-        result = JSON.parse(response.body)
+        result = parse_body(response.body)
         raise_rate_limit(response) if result['error'] == 'ratelimited'
         unless result['ok']
           message = result['error'] || 'Unknown error'
@@ -240,6 +240,17 @@ module Slk
         end
 
         result
+      end
+
+      # Every caller treats a response as a Hash and digs into it. Slack
+      # sending a bare array, string or null is not something any of them can
+      # act on, so it fails here as an API error rather than as a TypeError
+      # somewhere downstream.
+      def parse_body(body)
+        result = JSON.parse(body)
+        return result if result.is_a?(Hash)
+
+        raise ApiError.new('Unexpected response shape from Slack API', code: :invalid_response)
       rescue JSON::ParserError
         raise ApiError.new('Invalid JSON response from Slack API', code: :invalid_json)
       end

data/lib/slk/services/cache_store.rb

@@ -135,6 +135,19 @@ module Slk
         end
       end
 
+      # The meta cache holds everything that is neither a user nor a channel:
+      # start dates, the deactivation roster, resolved profiles. "Clear all
+      # caches" was not telling the truth while this was left behind.
+      def clear_meta_cache(workspace_name = nil)
+        if workspace_name
+          @meta_cache.delete(workspace_name)
+          FileUtils.rm_f(meta_cache_file(workspace_name))
+        else
+          @meta_cache.clear
+          Dir.glob(@paths.cache_file('meta-*.json')).each { |f| FileUtils.rm_f(f) }
+        end
+      end
+
       # Subteam cache methods
       def get_subteam(workspace_name, subteam_id)
         load_subteam_cache(workspace_name)
@@ -199,6 +212,12 @@ module Slk
         @on_warning&.call("#{cache_type} cache corrupted for #{workspace_name}: #{e.message}. Cache will be rebuilt.")
         safely_delete_file(file)
         {}
+      rescue SystemCallError, IOError => e
+        # An unreadable cache file is the same situation as a corrupt one:
+        # carry on without it. Not deleted, because a file we cannot read is
+        # one we probably cannot remove either, and it may not be ours.
+        @on_warning&.call("#{cache_type} cache unreadable for #{workspace_name}: #{e.message}. Continuing without it.")
+        {}
       end
 
       def safely_delete_file(file)

data/lib/slk/services/meta_cache.rb

@@ -7,6 +7,8 @@ module Slk
     module MetaCache
       module_function
 
+      # A write failure here is deliberately dropped: fetch's caller wants the
+      # value, and callers that need to report a cold cache use write directly.
       def fetch(cache_store, workspace_name, key, ttl: nil, refresh: false)
         cached = read(cache_store, workspace_name, key, ttl: ttl) unless refresh
         return cached if cached
@@ -22,10 +24,23 @@ module Slk
         cache_store.get_meta(workspace_name, key, ttl: ttl)
       end
 
+      # A cache write that fails must never cost the caller the work it just
+      # did — a full or read-only disk means "no cache", not "no answer", and
+      # some of these writes sit behind minutes of rate-limited API calls.
+      #
+      # A nil or false value is treated as nothing to store, since no caller
+      # caches a negative this way — the start date lookup caches per-user
+      # nils inside a Hash, which is a value like any other.
+      #
+      # @return [Exception, nil] the write failure, for callers that want to
+      #   mention it; nil when the write succeeded or there was nothing to do
       def write(cache_store, workspace_name, key, value)
-        return unless cache_store && workspace_name && value
+        return nil unless cache_store && workspace_name && value
 
         cache_store.set_meta(workspace_name, key, value)
+        nil
+      rescue SystemCallError, IOError => e
+        e
       end
     end
   end

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