slk 0.1.0 → 0.2.0

data/lib/slack_cli/models/message.rb

@@ -1,217 +0,0 @@
-# frozen_string_literal: true
-
-module SlackCli
-  module Models
-    Message = Data.define(
-      :ts,
-      :user_id,
-      :text,
-      :reactions,
-      :reply_count,
-      :thread_ts,
-      :files,
-      :attachments,
-      :blocks,
-      :user_profile,
-      :bot_profile,
-      :username,
-      :subtype,
-      :channel_id
-    ) do
-      # Minimum text length before we extract content from Block Kit blocks.
-      # Slack sometimes sends minimal text (like a link preview) with the full
-      # content in blocks. 20 chars catches most of these cases without
-      # unnecessarily processing blocks for normal messages.
-      BLOCK_TEXT_THRESHOLD = 20
-
-      def self.from_api(data, channel_id: nil)
-        text = data["text"] || ""
-        blocks = data["blocks"] || []
-
-        # Extract text from Block Kit blocks if text is empty or minimal
-        if text.length < BLOCK_TEXT_THRESHOLD
-          blocks_text = extract_block_text(blocks)
-          text = blocks_text unless blocks_text.empty?
-        end
-
-        new(
-          ts: data["ts"],
-          user_id: data["user"] || data["bot_id"] || data["username"],
-          text: text,
-          reactions: (data["reactions"] || []).map { |r| Reaction.from_api(r) },
-          reply_count: data["reply_count"] || 0,
-          thread_ts: data["thread_ts"],
-          files: data["files"] || [],
-          attachments: data["attachments"] || [],
-          blocks: blocks,
-          user_profile: data["user_profile"],
-          bot_profile: data["bot_profile"],
-          username: data["username"],
-          subtype: data["subtype"],
-          channel_id: channel_id
-        )
-      end
-
-      def self.extract_block_text(blocks)
-        return "" unless blocks.is_a?(Array)
-
-        blocks.filter_map do |block|
-          case block["type"]
-          when "section"
-            block.dig("text", "text")
-          when "rich_text"
-            extract_rich_text_content(block["elements"])
-          end
-        end.join("\n")
-      end
-
-      def self.extract_rich_text_content(elements)
-        return "" unless elements.is_a?(Array)
-
-        elements.filter_map do |element|
-          next unless element["elements"].is_a?(Array)
-
-          element["elements"].filter_map do |item|
-            item["text"] if item["type"] == "text"
-          end.join
-        end.join
-      end
-
-      def initialize(
-        ts:,
-        user_id:,
-        text: "",
-        reactions: [],
-        reply_count: 0,
-        thread_ts: nil,
-        files: [],
-        attachments: [],
-        blocks: [],
-        user_profile: nil,
-        bot_profile: nil,
-        username: nil,
-        subtype: nil,
-        channel_id: nil
-      )
-        ts_str = ts.to_s.strip
-        user_id_str = user_id.to_s.strip
-
-        raise ArgumentError, "ts cannot be empty" if ts_str.empty?
-        raise ArgumentError, "user_id cannot be empty" if user_id_str.empty?
-
-        super(
-          ts: ts_str.freeze,
-          user_id: user_id_str.freeze,
-          text: text.to_s.freeze,
-          reactions: reactions.freeze,
-          reply_count: reply_count.to_i,
-          thread_ts: thread_ts&.freeze,
-          files: deep_freeze(files),
-          attachments: deep_freeze(attachments),
-          blocks: deep_freeze(blocks),
-          user_profile: deep_freeze(user_profile),
-          bot_profile: deep_freeze(bot_profile),
-          username: username&.freeze,
-          subtype: subtype&.freeze,
-          channel_id: channel_id&.freeze
-        )
-      end
-
-      # Recursively freeze nested structures (arrays and hashes)
-      def self.deep_freeze(obj)
-        case obj
-        when Hash
-          obj.each_value { |v| deep_freeze(v) }
-          obj.freeze
-        when Array
-          obj.each { |v| deep_freeze(v) }
-          obj.freeze
-        else
-          obj.freeze if obj.respond_to?(:freeze)
-        end
-        obj
-      end
-
-      private_class_method :deep_freeze
-
-      # Instance method delegate to class method for use in initialize
-      def deep_freeze(obj)
-        self.class.send(:deep_freeze, obj)
-      end
-
-      def timestamp
-        Time.at(ts.to_f)
-      end
-
-      def has_thread?
-        reply_count > 0
-      end
-
-      def is_reply?
-        thread_ts && thread_ts != ts
-      end
-
-      def has_reactions?
-        !reactions.empty?
-      end
-
-      def has_files?
-        !files.empty?
-      end
-
-      def has_blocks?
-        !blocks.empty?
-      end
-
-      def embedded_username
-        # Try user_profile first (regular users)
-        if user_profile
-          display = user_profile["display_name"]
-          real = user_profile["real_name"]
-
-          return display unless display.to_s.empty?
-          return real unless real.to_s.empty?
-        end
-
-        # Try bot_profile (bot messages)
-        if bot_profile
-          name = bot_profile["name"]
-          return name unless name.to_s.empty?
-        end
-
-        # Fall back to username field (some bots/integrations)
-        return username unless username.to_s.empty?
-
-        nil
-      end
-
-      def bot?
-        user_id.start_with?("B") || subtype == "bot_message"
-      end
-
-      def system_message?
-        %w[channel_join channel_leave channel_topic channel_purpose].include?(subtype)
-      end
-
-      # Create a copy of this message with updated reactions
-      def with_reactions(new_reactions)
-        Message.new(
-          ts: ts,
-          user_id: user_id,
-          text: text,
-          reactions: new_reactions,
-          reply_count: reply_count,
-          thread_ts: thread_ts,
-          files: files,
-          attachments: attachments,
-          blocks: blocks,
-          user_profile: user_profile,
-          bot_profile: bot_profile,
-          username: username,
-          subtype: subtype,
-          channel_id: channel_id
-        )
-      end
-    end
-  end
-end

data/lib/slack_cli/models/preset.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module SlackCli
-  module Models
-    Preset = Data.define(:name, :text, :emoji, :duration, :presence, :dnd) do
-      def self.from_hash(name, data)
-        new(
-          name: name,
-          text: data["text"] || "",
-          emoji: data["emoji"] || "",
-          duration: data["duration"] || "0",
-          presence: data["presence"] || "",
-          dnd: data["dnd"] || ""
-        )
-      end
-
-      def initialize(name:, text: "", emoji: "", duration: "0", presence: "", dnd: "")
-        name_str = name.to_s.strip
-        raise ArgumentError, "preset name cannot be empty" if name_str.empty?
-
-        duration_str = duration.to_s
-        # Validate duration at construction time (will raise ArgumentError if invalid)
-        Duration.parse(duration_str) unless duration_str.empty? || duration_str == "0"
-
-        super(
-          name: name_str.freeze,
-          text: text.to_s.freeze,
-          emoji: emoji.to_s.freeze,
-          duration: duration_str.freeze,
-          presence: presence.to_s.freeze,
-          dnd: dnd.to_s.freeze
-        )
-      end
-
-      def to_h
-        {
-          "text" => text,
-          "emoji" => emoji,
-          "duration" => duration,
-          "presence" => presence,
-          "dnd" => dnd
-        }
-      end
-
-      def duration_value
-        Duration.parse(duration)
-      end
-
-      def sets_presence?
-        !presence.empty?
-      end
-
-      def sets_dnd?
-        !dnd.empty?
-      end
-
-      def clears_status?
-        text.empty? && emoji.empty?
-      end
-
-      def to_s
-        parts = []
-        parts << emoji unless emoji.empty?
-        parts << "\"#{text}\"" unless text.empty?
-        parts << "(#{duration})" unless duration == "0" || duration.empty?
-        parts << "[#{presence}]" if sets_presence?
-        parts << "{dnd: #{dnd}}" if sets_dnd?
-
-        "#{name}: #{parts.join(" ")}"
-      end
-    end
-  end
-end

data/lib/slack_cli/models/user.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module SlackCli
-  module Models
-    User = Data.define(:id, :name, :real_name, :display_name, :is_bot) do
-      def self.from_api(data)
-        profile = data["profile"] || {}
-
-        new(
-          id: data["id"],
-          name: data["name"],
-          real_name: profile["real_name"] || data["real_name"],
-          display_name: profile["display_name"] || profile["display_name_normalized"],
-          is_bot: data["is_bot"] || false
-        )
-      end
-
-      # Slack user IDs start with U or W (enterprise grid)
-      USER_ID_PATTERN = /\A[UW][A-Z0-9]+\z/
-
-      def initialize(id:, name: nil, real_name: nil, display_name: nil, is_bot: false)
-        id_str = id.to_s.strip
-        raise ArgumentError, "user id cannot be empty" if id_str.empty?
-
-        # Validate user ID format (starts with U or W followed by alphanumeric)
-        unless id_str.match?(USER_ID_PATTERN)
-          raise ArgumentError, "invalid user id format: #{id_str} (expected U or W prefix)"
-        end
-
-        super(
-          id: id_str.freeze,
-          name: name&.freeze,
-          real_name: real_name&.freeze,
-          display_name: display_name&.freeze,
-          is_bot: is_bot
-        )
-      end
-
-      def best_name
-        return display_name unless display_name.to_s.empty?
-        return real_name unless real_name.to_s.empty?
-        return name unless name.to_s.empty?
-
-        id
-      end
-
-      def mention
-        "@#{best_name}"
-      end
-
-      def to_s
-        best_name
-      end
-    end
-  end
-end

data/lib/slack_cli/models/workspace.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module SlackCli
-  module Models
-    Workspace = Data.define(:name, :token, :cookie) do
-      # Valid token prefixes for Slack tokens
-      VALID_TOKEN_PREFIXES = %w[xoxb- xoxc- xoxp-].freeze
-
-      def initialize(name:, token:, cookie: nil)
-        name_str = name.to_s.strip
-        token_str = token.to_s
-        cookie_str = cookie&.to_s
-
-        # Validate name is not empty and doesn't contain path separators
-        raise ArgumentError, "workspace name cannot be empty" if name_str.empty?
-        raise ArgumentError, "workspace name contains invalid characters" if name_str.match?(%r{[/\\]})
-
-        # Validate token format
-        unless VALID_TOKEN_PREFIXES.any? { |prefix| token_str.start_with?(prefix) }
-          raise ArgumentError, "invalid token format (must start with xoxb-, xoxc-, or xoxp-)"
-        end
-
-        # xoxc tokens require a cookie
-        if token_str.start_with?("xoxc-") && (cookie_str.nil? || cookie_str.strip.empty?)
-          raise ArgumentError, "xoxc tokens require a cookie"
-        end
-
-        # Validate cookie doesn't contain newlines (HTTP header injection prevention)
-        if cookie_str && cookie_str.match?(/[\r\n]/)
-          raise ArgumentError, "cookie cannot contain newlines"
-        end
-
-        super(name: name_str.freeze, token: token_str.freeze, cookie: cookie_str&.freeze)
-      end
-
-      def xoxc? = token.start_with?("xoxc-")
-      def xoxb? = token.start_with?("xoxb-")
-      def xoxp? = token.start_with?("xoxp-")
-
-      def to_s = name
-
-      def headers
-        h = {
-          "Authorization" => "Bearer #{token}",
-          "Content-Type" => "application/json; charset=utf-8"
-        }
-        h["Cookie"] = "d=#{cookie}" if cookie
-        h
-      end
-    end
-  end
-end

data/lib/slack_cli/services/api_client.rb

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-
-module SlackCli
-  module Services
-    class ApiClient
-      BASE_URL = ENV.fetch("SLACK_API_BASE", "https://slack.com/api")
-
-      # Network errors that should be wrapped in ApiError
-      NETWORK_ERRORS = [
-        SocketError,
-        Errno::ECONNREFUSED,
-        Errno::ECONNRESET,
-        Errno::ETIMEDOUT,
-        Errno::EHOSTUNREACH,
-        Net::OpenTimeout,
-        Net::ReadTimeout,
-        OpenSSL::SSL::SSLError
-      ].freeze
-
-      attr_reader :call_count
-      attr_accessor :on_request
-
-      def initialize
-        @call_count = 0
-        @on_request = nil
-        @http_cache = {}
-      end
-
-      # Close all cached HTTP connections
-      def close
-        @http_cache.each_value do |http|
-          http.finish if http.started?
-        rescue IOError
-          # Connection already closed
-        end
-        @http_cache.clear
-      end
-
-      def post(workspace, method, params = {})
-        log_request(method)
-        uri = URI("#{BASE_URL}/#{method}")
-
-        http = get_http(uri)
-
-        request = Net::HTTP::Post.new(uri)
-        workspace.headers.each { |k, v| request[k] = v }
-        request.body = JSON.generate(params) unless params.empty?
-
-        response = http.request(request)
-        handle_response(response, method)
-      rescue *NETWORK_ERRORS => e
-        raise ApiError, "Network error: #{e.message}"
-      end
-
-      def get(workspace, method, params = {})
-        log_request(method)
-        uri = URI("#{BASE_URL}/#{method}")
-        uri.query = URI.encode_www_form(params) unless params.empty?
-
-        http = get_http(uri)
-
-        request = Net::HTTP::Get.new(uri)
-        request["Authorization"] = workspace.headers["Authorization"]
-        request["Cookie"] = workspace.headers["Cookie"] if workspace.headers["Cookie"]
-
-        response = http.request(request)
-        handle_response(response, method)
-      rescue *NETWORK_ERRORS => e
-        raise ApiError, "Network error: #{e.message}"
-      end
-
-      # Form-encoded POST (some Slack endpoints require this)
-      def post_form(workspace, method, params = {})
-        log_request(method)
-        uri = URI("#{BASE_URL}/#{method}")
-
-        http = get_http(uri)
-
-        request = Net::HTTP::Post.new(uri)
-        request["Authorization"] = workspace.headers["Authorization"]
-        request["Cookie"] = workspace.headers["Cookie"] if workspace.headers["Cookie"]
-        request.set_form_data(params)
-
-        response = http.request(request)
-        handle_response(response, method)
-      rescue *NETWORK_ERRORS => e
-        raise ApiError, "Network error: #{e.message}"
-      end
-
-      private
-
-      def log_request(method)
-        @call_count += 1
-        @on_request&.call(method, @call_count)
-      end
-
-      # Get or create a persistent HTTP connection for the given URI
-      def get_http(uri)
-        key = "#{uri.host}:#{uri.port}"
-        cached = @http_cache[key]
-
-        # Return cached connection if it's still active
-        if cached && cached.started?
-          return cached
-        end
-
-        # Create new connection
-        http = Net::HTTP.new(uri.host, uri.port)
-        configure_ssl(http, uri)
-        http.start
-
-        @http_cache[key] = http
-        http
-      end
-
-      def configure_ssl(http, uri)
-        http.use_ssl = uri.scheme == "https"
-        http.open_timeout = 10
-        http.read_timeout = 30
-        http.keep_alive_timeout = 30
-
-        return unless http.use_ssl?
-
-        # Use system certificate store for SSL verification
-        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        http.cert_store = OpenSSL::X509::Store.new
-        http.cert_store.set_default_paths
-      end
-
-      def handle_response(response, method)
-        case response
-        when Net::HTTPSuccess
-          result = JSON.parse(response.body)
-          raise ApiError, result["error"] || "Unknown error" unless result["ok"]
-
-          result
-        when Net::HTTPUnauthorized
-          raise ApiError, "Invalid token or session expired"
-        when Net::HTTPTooManyRequests
-          raise ApiError, "Rate limited - please wait and try again"
-        else
-          raise ApiError, "HTTP #{response.code}: #{response.message}"
-        end
-      rescue JSON::ParserError
-        raise ApiError, "Invalid JSON response from Slack API"
-      end
-    end
-  end
-end

data/lib/slack_cli/services/reaction_enricher.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module SlackCli
-  module Services
-    class ReactionEnricher
-      def initialize(activity_api:)
-        @activity_api = activity_api
-      end
-
-      # Enriches messages with reaction timestamps
-      # Returns new array of messages with timestamps added to reactions
-      def enrich_messages(messages, channel_id)
-        return messages if messages.empty?
-
-        # Fetch reaction activity
-        activity_map = fetch_reaction_activity(channel_id, messages.map(&:ts))
-
-        # Enhance messages with timestamps
-        messages.map do |msg|
-          enhanced_reactions = enhance_reactions(msg, activity_map)
-          msg.with_reactions(enhanced_reactions)
-        end
-      end
-
-      private
-
-      def fetch_reaction_activity(channel_id, message_timestamps)
-        # Fetch first page of recent reactions (max 50 per API limit)
-        # Note: This may not cover all historical reactions, but that's acceptable
-        # for performance reasons. Older reactions simply won't have timestamps.
-        response = @activity_api.feed(limit: 50, types: 'message_reaction')
-        return {} unless response['ok']
-
-        # Build map: "channel_id:message_ts:emoji:user" => timestamp
-        activity_map = {}
-        items = response['items'] || []
-
-        items.each do |item|
-          next unless item.dig('item', 'type') == 'message_reaction'
-
-          msg_data = item.dig('item', 'message')
-          reaction_data = item.dig('item', 'reaction')
-          next unless msg_data && reaction_data
-
-          # Only include reactions for messages we care about
-          msg_ts = msg_data['ts']
-          next unless message_timestamps.include?(msg_ts)
-
-          key = [
-            msg_data['channel'],
-            msg_ts,
-            reaction_data['name'],
-            reaction_data['user']
-          ].join(':')
-
-          activity_map[key] = item['feed_ts']
-        end
-
-        activity_map
-      rescue SlackCli::ApiError
-        # If activity API fails, gracefully degrade - return empty map
-        # Messages will still be displayed, just without reaction timestamps
-        {}
-      end
-
-      def enhance_reactions(message, activity_map)
-        return message.reactions if message.reactions.empty?
-
-        message.reactions.map do |reaction|
-          timestamp_map = {}
-
-          reaction.users.each do |user_id|
-            key = [message.channel_id, message.ts, reaction.name, user_id].join(':')
-            timestamp_map[user_id] = activity_map[key] if activity_map[key]
-          end
-
-          # Only create a new reaction with timestamps if we found any
-          if timestamp_map.empty?
-            reaction
-          else
-            reaction.with_timestamps(timestamp_map)
-          end
-        end
-      end
-    end
-  end
-end