slk 0.2.0 → 0.4.0

data/lib/slk/formatters/mention_replacer.rb

@@ -30,6 +30,11 @@ module Slk
         replace_special_mentions(result)
       end
 
+      # Public API for looking up user names (used by MessageFormatter)
+      def lookup_user_name(workspace, user_id)
+        user_lookup_for(workspace).resolve_name(user_id)
+      end
+
       private
 
       def replace_user_mentions(text, workspace)
@@ -76,42 +81,19 @@ module Slk
 
       def lookup_by_type(workspace, id, type)
         case type
-        when :user then lookup_user_name(workspace, id)
+        when :user then user_lookup_for(workspace).resolve_name(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 }
+      def user_lookup_for(workspace)
+        Services::UserLookup.new(
+          cache_store: @cache,
+          workspace: workspace,
+          api_client: @api,
+          on_debug: @on_debug
+        )
       end
 
       def lookup_channel_name(workspace, channel_id)

data/lib/slk/formatters/message_formatter.rb

@@ -105,23 +105,16 @@ module Slk
         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)
+        user_lookup_for(workspace).resolve_name_or_bot(message.user_id) || 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
+      def user_lookup_for(workspace)
+        Services::UserLookup.new(
+          cache_store: @cache,
+          workspace: workspace,
+          api_client: @api_client,
+          on_debug: @on_debug
+        )
       end
 
       def format_timestamp(time)

data/lib/slk/formatters/search_formatter.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Slk
+  module Formatters
+    # Formats search results for terminal display
+    class SearchFormatter
+      def initialize(output:, emoji_replacer:, mention_replacer:)
+        @output = output
+        @emoji = emoji_replacer
+        @mentions = mention_replacer
+      end
+
+      # Display a list of search results
+      def display_all(results, workspace, options: {})
+        return @output.puts 'No results found.' if results.empty?
+
+        results.each_with_index do |result, index|
+          display_result(result, workspace, options)
+          @output.puts if index < results.length - 1
+        end
+      end
+
+      # Display a single search result
+      def display_result(result, workspace, options = {})
+        timestamp = @output.blue("[#{format_time(result.timestamp)}]")
+        channel = @output.cyan(resolve_channel(result, workspace))
+        user = @output.bold("#{resolve_user(result, workspace)}:")
+        text = prepare_text(result.text, workspace, options)
+
+        @output.puts "#{timestamp} #{channel} #{user} #{text}"
+        display_files(result.files) if result.files&.any?
+      end
+
+      private
+
+      def resolve_channel(result, workspace)
+        if result.dm?
+          # For DMs, channel_name is a user ID - resolve it
+          @mentions.replace("<@#{result.channel_name}>", workspace)
+        else
+          "##{result.channel_name}"
+        end
+      end
+
+      def resolve_user(result, workspace)
+        # If we have a username, use it directly
+        return result.username if result.username && !result.username.empty?
+
+        # Fallback if user_id is also missing
+        return 'Unknown User' unless result.user_id && !result.user_id.to_s.empty?
+
+        # Otherwise resolve the user_id via MentionReplacer
+        @mentions.replace("<@#{result.user_id}>", workspace)
+      end
+
+      def prepare_text(text, workspace, options)
+        return text if options[:no_emoji] && options[:no_mentions]
+
+        text = @emoji.replace(text) unless options[:no_emoji]
+        text = @mentions.replace(text, workspace) unless options[:no_mentions]
+        text
+      end
+
+      def display_files(files)
+        files.each do |file|
+          @output.puts @output.blue("[Image: #{file[:name]}]")
+        end
+      end
+
+      def format_time(time)
+        time.strftime('%Y-%m-%d %H:%M')
+      end
+    end
+  end
+end

data/lib/slk/models/search_result.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Slk
+  module Models
+    # Value object for search.messages API results
+    # Search results include channel info inline, unlike regular messages
+    SearchResult = Data.define(
+      :ts,
+      :user_id,
+      :username,
+      :text,
+      :channel_id,
+      :channel_name,
+      :channel_type,
+      :thread_ts,
+      :permalink,
+      :files
+    ) do
+      def self.from_api(match)
+        channel = match['channel'] || {}
+        new(**build_attributes(match, channel))
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def self.build_attributes(match, channel)
+        {
+          ts: match['ts'],
+          user_id: match['user'] || match['username'],
+          username: match['username'],
+          text: match['text'] || '',
+          channel_id: channel['id'],
+          channel_name: channel['name'],
+          channel_type: determine_channel_type(channel),
+          thread_ts: extract_thread_ts(match),
+          permalink: match['permalink'],
+          files: extract_files(match)
+        }
+      end
+
+      def self.extract_files(match)
+        files = extract_uploaded_files(match)
+        files += extract_attachments(match)
+        files
+      end
+
+      def self.extract_uploaded_files(match)
+        return [] unless match['files']
+
+        match['files'].map { |f| { name: f['name'], type: f['filetype'] } }
+      end
+
+      def self.extract_attachments(match)
+        return [] unless match['attachments']
+
+        match['attachments'].flat_map { |a| extract_attachment_images(a) }
+      end
+
+      def self.extract_attachment_images(attachment)
+        unless attachment['blocks']
+          fallback = attachment['fallback']
+          return [] unless fallback
+
+          return [{ name: fallback, type: 'attachment' }]
+        end
+
+        attachment['blocks'].filter_map do |block|
+          next unless block['type'] == 'image'
+
+          { name: block.dig('title', 'text') || 'Image', type: 'attachment' }
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def self.determine_channel_type(channel)
+        return 'im' if channel['is_im']
+        return 'mpim' if channel['is_mpim']
+
+        'channel'
+      end
+
+      def self.extract_thread_ts(match)
+        return nil unless match['permalink']
+
+        # Extract thread_ts from permalink URL if present
+        uri = URI.parse(match['permalink'])
+        params = URI.decode_www_form(uri.query || '')
+        params.find { |k, _| k == 'thread_ts' }&.last
+      rescue URI::InvalidURIError => e
+        # Log for debugging - malformed permalinks from API should be rare
+        warn "Invalid permalink URI: #{match['permalink']}: #{e.message}" if ENV['DEBUG']
+        nil
+      end
+
+      def timestamp
+        Time.at(ts.to_f)
+      end
+
+      def thread?
+        !thread_ts.nil?
+      end
+
+      def dm?
+        %w[im mpim].include?(channel_type)
+      end
+
+      def display_channel
+        if dm?
+          "@#{channel_name}"
+        else
+          "##{channel_name}"
+        end
+      end
+    end
+  end
+end

data/lib/slk/runner.rb

@@ -79,6 +79,10 @@ module Slk
       Api::Activity.new(@api_client, workspace(workspace_name))
     end
 
+    def search_api(workspace_name = nil)
+      Api::Search.new(@api_client, workspace(workspace_name))
+    end
+
     # Formatter helpers
     def message_formatter
       @message_formatter ||= Formatters::MessageFormatter.new(
@@ -107,6 +111,14 @@ module Slk
       @duration_formatter ||= Formatters::DurationFormatter.new
     end
 
+    def search_formatter
+      @search_formatter ||= Formatters::SearchFormatter.new(
+        output: @output,
+        emoji_replacer: emoji_replacer,
+        mention_replacer: mention_replacer
+      )
+    end
+
     # Logging
     def log_error(error)
       Support::ErrorLogger.log(error)

data/lib/slk/services/api_client.rb

@@ -20,11 +20,14 @@ module Slk
       ].freeze
 
       attr_reader :call_count
-      attr_accessor :on_request
+      attr_accessor :on_request, :on_response, :on_request_body, :on_response_body
 
       def initialize
         @call_count = 0
         @on_request = nil
+        @on_response = nil
+        @on_request_body = nil
+        @on_response_body = nil
         @http_cache = {}
       end
 
@@ -35,10 +38,11 @@ module Slk
       end
 
       def post(workspace, method, params = {})
-        execute_request(method) do |uri, http|
+        body = params.empty? ? nil : JSON.generate(params)
+        execute_request(method, body: body) do |uri, http|
           request = Net::HTTP::Post.new(uri)
           workspace.headers.each { |k, v| request[k] = v }
-          request.body = JSON.generate(params) unless params.empty?
+          request.body = body
           http.request(request)
         end
       end
@@ -53,10 +57,11 @@ module Slk
 
       # Form-encoded POST (some Slack endpoints require this)
       def post_form(workspace, method, params = {})
-        execute_request(method) do |uri, http|
+        body = params.empty? ? nil : URI.encode_www_form(params)
+        execute_request(method, body: body) do |uri, http|
           request = Net::HTTP::Post.new(uri)
           apply_auth_headers(request, workspace)
-          request.set_form_data(params)
+          request.set_form_data(params) unless params.empty?
           http.request(request)
         end
       end
@@ -66,19 +71,33 @@ module Slk
       def safe_close(http)
         http.finish if http.started?
       rescue IOError
-        # Connection already closed
+        # Connection already closed - this is expected, not an error
       end
 
-      def execute_request(method, query_params = nil)
+      def execute_request(method, query_params = nil, body: nil, &)
         log_request(method)
+        log_request_body(method, body)
+        uri = build_uri(method, query_params)
+        response, elapsed_ms = timed_request(uri, &)
+        log_response(method, response, elapsed_ms)
+        log_response_body(method, response.body)
+        handle_response(response, method)
+      rescue *NETWORK_ERRORS => e
+        raise ApiError, "Network error: #{e.message}"
+      end
+
+      def build_uri(method, query_params)
         uri = URI("#{BASE_URL}/#{method}")
         uri.query = URI.encode_www_form(query_params) if query_params&.any?
+        uri
+      end
 
+      def timed_request(uri)
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         http = get_http(uri)
         response = yield(uri, http)
-        handle_response(response, method)
-      rescue *NETWORK_ERRORS => e
-        raise ApiError, "Network error: #{e.message}"
+        elapsed_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(1)
+        [response, elapsed_ms]
       end
 
       def apply_auth_headers(request, workspace)
@@ -91,6 +110,29 @@ module Slk
         @on_request&.call(method, @call_count)
       end
 
+      def log_request_body(method, body)
+        @on_request_body&.call(method, body) if body
+      end
+
+      def log_response(method, response, elapsed_ms)
+        return unless @on_response
+
+        headers = {
+          'elapsed_ms' => elapsed_ms,
+          'X-Slack-Req-Id' => response['X-Slack-Req-Id'],
+          'X-RateLimit-Limit' => response['X-RateLimit-Limit'],
+          'X-RateLimit-Remaining' => response['X-RateLimit-Remaining'],
+          'X-RateLimit-Reset' => response['X-RateLimit-Reset'],
+          'Retry-After' => response['Retry-After']
+        }.compact
+
+        @on_response.call(method, response.code, headers)
+      end
+
+      def log_response_body(method, body)
+        @on_response_body&.call(method, body) if body
+      end
+
       # Get or create a persistent HTTP connection for the given URI
       def get_http(uri)
         key = "#{uri.host}:#{uri.port}"
@@ -126,11 +168,18 @@ module Slk
         case response
         when Net::HTTPSuccess then parse_success_response(response)
         when Net::HTTPUnauthorized then raise ApiError, 'Invalid token or session expired'
-        when Net::HTTPTooManyRequests then raise ApiError, 'Rate limited - please wait and try again'
+        when Net::HTTPTooManyRequests then handle_rate_limit(response)
         else raise ApiError, "HTTP #{response.code}: #{response.message}"
         end
       end
 
+      def handle_rate_limit(response)
+        retry_after = response['Retry-After']
+        raise ApiError, "Rate limited - retry after #{retry_after} seconds" if retry_after
+
+        raise ApiError, 'Rate limited - please wait and try again'
+      end
+
       def parse_success_response(response)
         result = JSON.parse(response.body)
         raise ApiError, result['error'] || 'Unknown error' unless result['ok']

data/lib/slk/services/cache_store.rb

@@ -5,7 +5,7 @@ module Slk
     # Persistent cache for user names, channel names, and subteams
     # rubocop:disable Metrics/ClassLength
     class CacheStore
-      attr_accessor :on_warning
+      attr_accessor :on_warning, :on_cache_access
 
       def initialize(paths: nil)
         @paths = paths || Support::XdgPaths.new
@@ -13,12 +13,24 @@ module Slk
         @channel_cache = {}
         @subteam_cache = {}
         @on_warning = nil
+        @on_cache_access = nil
       end
 
       # User cache methods
       def get_user(workspace_name, user_id)
         load_user_cache(workspace_name)
-        @user_cache.dig(workspace_name, user_id)
+        result = @user_cache.dig(workspace_name, user_id)
+        log_cache_access('user', workspace_name, user_id, result)
+        result
+      end
+
+      def get_user_id_by_name(workspace_name, name)
+        load_user_cache(workspace_name)
+        cache = @user_cache[workspace_name] || {}
+        # Reverse lookup: find user_id where display_name matches
+        result = cache.find { |_id, display_name| display_name == name }&.first
+        log_cache_access('user_by_name', workspace_name, name, result)
+        result
       end
 
       def set_user(workspace_name, user_id, display_name, persist: false)
@@ -66,13 +78,17 @@ module Slk
       # Channel cache methods
       def get_channel_id(workspace_name, channel_name)
         load_channel_cache(workspace_name)
-        @channel_cache.dig(workspace_name, channel_name)
+        result = @channel_cache.dig(workspace_name, channel_name)
+        log_cache_access('channel_id', workspace_name, channel_name, result)
+        result
       end
 
       def get_channel_name(workspace_name, channel_id)
         load_channel_cache(workspace_name)
         cache = @channel_cache[workspace_name] || {}
-        cache.key(channel_id)
+        result = cache.key(channel_id)
+        log_cache_access('channel_name', workspace_name, channel_id, result)
+        result
       end
 
       def set_channel(workspace_name, channel_name, channel_id)
@@ -95,7 +111,9 @@ module Slk
       # Subteam cache methods
       def get_subteam(workspace_name, subteam_id)
         load_subteam_cache(workspace_name)
-        @subteam_cache.dig(workspace_name, subteam_id)
+        result = @subteam_cache.dig(workspace_name, subteam_id)
+        log_cache_access('subteam', workspace_name, subteam_id, result)
+        result
       end
 
       def set_subteam(workspace_name, subteam_id, handle)
@@ -129,29 +147,37 @@ module Slk
       def load_user_cache(workspace_name)
         return if @user_cache.key?(workspace_name)
 
-        file = user_cache_file(workspace_name)
-        @user_cache[workspace_name] = if File.exist?(file)
-                                        JSON.parse(File.read(file))
-                                      else
-                                        {}
-                                      end
-      rescue JSON::ParserError => e
-        @on_warning&.call("User cache corrupted for #{workspace_name}: #{e.message}")
-        @user_cache[workspace_name] = {}
+        @user_cache[workspace_name] = load_cache_file(user_cache_file(workspace_name), 'User', workspace_name)
       end
 
       def load_channel_cache(workspace_name)
         return if @channel_cache.key?(workspace_name)
 
-        file = channel_cache_file(workspace_name)
-        @channel_cache[workspace_name] = if File.exist?(file)
-                                           JSON.parse(File.read(file))
-                                         else
-                                           {}
-                                         end
+        @channel_cache[workspace_name] = load_cache_file(channel_cache_file(workspace_name), 'Channel', workspace_name)
+      end
+
+      def load_subteam_cache(workspace_name)
+        return if @subteam_cache.key?(workspace_name)
+
+        @subteam_cache[workspace_name] = load_cache_file(subteam_cache_file(workspace_name), 'Subteam', workspace_name)
+      end
+
+      # Load and parse a JSON cache file, returning empty hash if missing.
+      # Corrupted files are deleted and rebuilt on next access.
+      def load_cache_file(file, cache_type, workspace_name)
+        return {} unless File.exist?(file)
+
+        JSON.parse(File.read(file))
       rescue JSON::ParserError => e
-        @on_warning&.call("Channel cache corrupted for #{workspace_name}: #{e.message}")
-        @channel_cache[workspace_name] = {}
+        @on_warning&.call("#{cache_type} cache corrupted for #{workspace_name}: #{e.message}. Cache will be rebuilt.")
+        safely_delete_file(file)
+        {}
+      end
+
+      def safely_delete_file(file)
+        FileUtils.rm(file)
+      rescue Errno::EACCES, Errno::EPERM, Errno::EROFS => e
+        @on_warning&.call("Could not remove corrupted cache file: #{e.message}")
       end
 
       def save_channel_cache(workspace_name)
@@ -170,20 +196,6 @@ module Slk
         @paths.cache_file("channels-#{workspace_name}.json")
       end
 
-      def load_subteam_cache(workspace_name)
-        return if @subteam_cache.key?(workspace_name)
-
-        file = subteam_cache_file(workspace_name)
-        @subteam_cache[workspace_name] = if File.exist?(file)
-                                           JSON.parse(File.read(file))
-                                         else
-                                           {}
-                                         end
-      rescue JSON::ParserError => e
-        @on_warning&.call("Subteam cache corrupted for #{workspace_name}: #{e.message}")
-        @subteam_cache[workspace_name] = {}
-      end
-
       def save_subteam_cache(workspace_name)
         return if @subteam_cache[workspace_name].nil? || @subteam_cache[workspace_name].empty?
 
@@ -195,6 +207,13 @@ module Slk
       def subteam_cache_file(workspace_name)
         @paths.cache_file("subteams-#{workspace_name}.json")
       end
+
+      def log_cache_access(type, workspace, key, result)
+        return unless @on_cache_access
+
+        hit = !result.nil?
+        @on_cache_access.call(type, workspace, key, hit, result)
+      end
     end
     # rubocop:enable Metrics/ClassLength
   end