slk 0.1.0 → 0.2.0

data/lib/slk/models/duration.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Slk
+  module Models
+    # Duration unit multipliers (seconds per unit)
+    DURATION_UNITS = { 'h' => 3600, 'm' => 60, 's' => 1 }.freeze
+
+    Duration = Data.define(:seconds) do
+      class << self
+        def parse(input)
+          return new(seconds: 0) if input.nil? || input.to_s.strip.empty?
+          return new(seconds: input.to_i) if input.to_s.match?(/^\d+$/)
+
+          parse_duration_string(input.to_s.downcase, input)
+        end
+
+        def zero = new(seconds: 0)
+
+        def from_minutes(minutes)
+          new(seconds: minutes.to_i * 60)
+        end
+
+        private
+
+        def parse_duration_string(str, original)
+          validate_no_duplicate_units(str, original)
+          total = calculate_total_seconds(str)
+          raise ArgumentError, "Invalid duration format: #{original}" if total.zero? && !str.match?(/^0/)
+
+          new(seconds: total)
+        end
+
+        def validate_no_duplicate_units(str, original)
+          DURATION_UNITS.each_key do |unit|
+            next unless str.scan(/\d+#{unit}/).length > 1
+
+            raise ArgumentError, "Duplicate '#{unit}' unit in duration: #{original}"
+          end
+        end
+
+        def calculate_total_seconds(str)
+          DURATION_UNITS.sum do |unit, multiplier|
+            (match = str.match(/(\d+)#{unit}/)) ? match[1].to_i * multiplier : 0
+          end
+        end
+      end
+
+      def zero? = seconds.zero?
+
+      def to_minutes = (seconds / 60.0).ceil
+
+      def to_expiration
+        return 0 if zero?
+
+        Time.now.to_i + seconds
+      end
+
+      def to_s
+        return '' if zero?
+
+        format_duration
+      end
+
+      def +(other)
+        Duration.new(seconds: seconds + other.seconds)
+      end
+
+      def -(other)
+        Duration.new(seconds: [seconds - other.seconds, 0].max)
+      end
+
+      private
+
+      def format_duration
+        parts = []
+        remaining = seconds
+
+        _hours, remaining = extract_unit(remaining, 3600, 'h', parts)
+        _minutes, remaining = extract_unit(remaining, 60, 'm', parts)
+        parts << "#{remaining}s" if remaining.positive? && parts.empty?
+
+        parts.join
+      end
+
+      def extract_unit(remaining, divisor, suffix, parts)
+        return [0, remaining] if remaining < divisor
+
+        value = remaining / divisor
+        parts << "#{value}#{suffix}"
+        [value, remaining % divisor]
+      end
+    end
+  end
+end

data/lib/slk/models/message.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ModuleLength
+module Slk
+  module Models
+    # 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.
+    MESSAGE_BLOCK_TEXT_THRESHOLD = 20
+
+    Message = Data.define(
+      :ts,
+      :user_id,
+      :text,
+      :reactions,
+      :reply_count,
+      :thread_ts,
+      :files,
+      :attachments,
+      :blocks,
+      :user_profile,
+      :bot_profile,
+      :username,
+      :subtype,
+      :channel_id
+    ) do
+      def self.from_api(data, channel_id: nil)
+        text = extract_message_text(data)
+        new(**build_attributes(data, text, channel_id))
+      end
+
+      def self.extract_message_text(data)
+        text = data['text'] || ''
+        blocks = data['blocks'] || []
+
+        return text if text.length >= MESSAGE_BLOCK_TEXT_THRESHOLD
+
+        blocks_text = extract_block_text(blocks)
+        blocks_text.empty? ? text : blocks_text
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def self.build_attributes(data, text, channel_id)
+        {
+          ts: data['ts'],
+          user_id: data['user'] || data['bot_id'] || data['username'],
+          text: text,
+          reactions: parse_reactions(data['reactions']),
+          reply_count: data['reply_count'] || 0,
+          thread_ts: data['thread_ts'],
+          files: data['files'] || [],
+          attachments: data['attachments'] || [],
+          blocks: data['blocks'] || [],
+          user_profile: data['user_profile'],
+          bot_profile: data['bot_profile'],
+          username: data['username'],
+          subtype: data['subtype'],
+          channel_id: channel_id
+        }
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def self.parse_reactions(reactions_data)
+        (reactions_data || []).map { |r| Reaction.from_api(r) }
+      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
+
+      # rubocop:disable Metrics/ParameterLists, Naming/MethodParameterName
+      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
+      )
+        validate_required_fields!(ts, user_id)
+        super(**freeze_attributes(
+          ts: ts, user_id: user_id, text: text, reactions: 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
+      # rubocop:enable Metrics/ParameterLists, Naming/MethodParameterName
+
+      def validate_required_fields!(timestamp, user)
+        ts_str = timestamp.to_s.strip
+        user_id_str = user.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?
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def freeze_attributes(attrs)
+        {
+          ts: attrs[:ts].to_s.strip.freeze,
+          user_id: attrs[:user_id].to_s.strip.freeze,
+          text: attrs[:text].to_s.freeze,
+          reactions: attrs[:reactions].freeze,
+          reply_count: attrs[:reply_count].to_i,
+          thread_ts: attrs[:thread_ts]&.freeze,
+          files: deep_freeze(attrs[:files]),
+          attachments: deep_freeze(attrs[:attachments]),
+          blocks: deep_freeze(attrs[:blocks]),
+          user_profile: deep_freeze(attrs[:user_profile]),
+          bot_profile: deep_freeze(attrs[:bot_profile]),
+          username: attrs[:username]&.freeze,
+          subtype: attrs[:subtype]&.freeze,
+          channel_id: attrs[:channel_id]&.freeze
+        }
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+      # Recursively freeze nested structures (arrays and hashes)
+      def self.deep_freeze(obj)
+        case obj
+        when Hash then freeze_hash(obj)
+        when Array then freeze_array(obj)
+        else obj.freeze if obj.respond_to?(:freeze)
+        end
+        obj
+      end
+
+      def self.freeze_hash(hash)
+        hash.each_value { |v| deep_freeze(v) }
+        hash.freeze
+      end
+
+      def self.freeze_array(array)
+        array.each { |v| deep_freeze(v) }
+        array.freeze
+      end
+
+      private_class_method :deep_freeze, :freeze_hash, :freeze_array
+
+      # 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 thread?
+        reply_count.positive?
+      end
+
+      def reply?
+        thread_ts && thread_ts != ts
+      end
+
+      def reactions?
+        !reactions.empty?
+      end
+
+      def files?
+        !files.empty?
+      end
+
+      def blocks?
+        !blocks.empty?
+      end
+
+      def embedded_username
+        username_from_user_profile || username_from_bot_profile || fallback_username
+      end
+
+      def username_from_user_profile
+        return nil unless user_profile
+
+        display = user_profile['display_name']
+        return display unless display.to_s.empty?
+
+        real = user_profile['real_name']
+        return real unless real.to_s.empty?
+
+        nil
+      end
+
+      def username_from_bot_profile
+        return nil unless bot_profile
+
+        name = bot_profile['name']
+        name.to_s.empty? ? nil : name
+      end
+
+      def fallback_username
+        username.to_s.empty? ? nil : username
+      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(**to_h, reactions: new_reactions)
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ModuleLength

data/lib/slk/models/preset.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Slk
+  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
+
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(name:, text: '', emoji: '', duration: '0', presence: '', dnd: '')
+        validate_name!(name)
+        validate_duration!(duration)
+
+        super(
+          name: name.to_s.strip.freeze,
+          text: text.to_s.freeze, emoji: emoji.to_s.freeze, duration: duration.to_s.freeze,
+          presence: presence.to_s.freeze, dnd: dnd.to_s.freeze
+        )
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      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
+        "#{name}: #{build_parts.join(' ')}"
+      end
+
+      private
+
+      def validate_name!(name)
+        raise ArgumentError, 'preset name cannot be empty' if name.to_s.strip.empty?
+      end
+
+      def validate_duration!(duration)
+        duration_str = duration.to_s
+        Duration.parse(duration_str) unless duration_str.empty? || duration_str == '0'
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def build_parts
+        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?
+        parts
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/{slack_cli → slk}/models/reaction.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Models
     Reaction = Data.define(:name, :count, :users, :timestamps) do
       def self.from_api(data)
         new(
-          name: data["name"],
-          count: data["count"] || 0,
-          users: data["users"] || [],
-          timestamps: nil  # Will be populated by ReactionEnricher
+          name: data['name'],
+          count: data['count'] || 0,
+          users: data['users'] || [],
+          timestamps: nil # Will be populated by ReactionEnricher
         )
       end
 
@@ -34,7 +34,7 @@ module SlackCli
         )
       end
 
-      def has_timestamps?
+      def timestamps?
         !timestamps.nil? && !timestamps.empty?
       end
 

data/lib/{slack_cli → slk}/models/status.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Models
     Status = Data.define(:text, :emoji, :expiration) do
-      def initialize(text: "", emoji: "", expiration: 0)
+      def initialize(text: '', emoji: '', expiration: 0)
         exp_val = expiration.to_i
         exp_val = 0 if exp_val.negative? # Normalize invalid negative expirations
 
@@ -19,7 +19,7 @@ module SlackCli
       end
 
       def expires?
-        expiration > 0
+        expiration.positive?
       end
 
       def expired?
@@ -30,7 +30,7 @@ module SlackCli
         return nil unless expires?
 
         remaining = expiration - Time.now.to_i
-        remaining > 0 ? Duration.new(seconds: remaining) : nil
+        remaining.positive? ? Duration.new(seconds: remaining) : nil
       end
 
       def expiration_time
@@ -40,7 +40,7 @@ module SlackCli
       end
 
       def to_s
-        return "(no status)" if empty?
+        return '(no status)' if empty?
 
         parts = []
         parts << emoji unless emoji.empty?
@@ -50,7 +50,7 @@ module SlackCli
           parts << "(#{remaining})"
         end
 
-        parts.join(" ")
+        parts.join(' ')
       end
     end
   end

data/lib/slk/models/user.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Slk
+  module Models
+    # Slack user IDs start with U or W (enterprise grid)
+    USER_ID_PATTERN = /\A[UW][A-Z0-9]+\z/
+
+    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
+
+      def initialize(id:, name: nil, real_name: nil, display_name: nil, is_bot: false)
+        id_str = id.to_s.strip
+        validate_id!(id_str)
+
+        super(
+          id: id_str.freeze, name: name&.freeze, real_name: real_name&.freeze,
+          display_name: display_name&.freeze, is_bot: is_bot
+        )
+      end
+
+      def validate_id!(id_str)
+        raise ArgumentError, 'user id cannot be empty' if id_str.empty?
+        return if id_str.match?(USER_ID_PATTERN)
+
+        raise ArgumentError, "invalid user id format: #{id_str} (expected U or W prefix)"
+      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/slk/models/workspace.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Slk
+  module Models
+    # Valid token prefixes for Slack tokens
+    VALID_TOKEN_PREFIXES = %w[xoxb- xoxc- xoxp-].freeze
+
+    Workspace = Data.define(:name, :token, :cookie) do
+      def initialize(name:, token:, cookie: nil)
+        name_str = name.to_s.strip
+        token_str = token.to_s
+        cookie_str = cookie&.to_s
+
+        validate_name!(name_str)
+        validate_token!(token_str)
+        validate_cookie!(token_str, cookie_str)
+
+        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
+
+      private
+
+      def validate_name!(name_str)
+        raise ArgumentError, 'workspace name cannot be empty' if name_str.empty?
+        raise ArgumentError, 'workspace name contains invalid characters' if name_str.match?(%r{[/\\]})
+      end
+
+      def validate_token!(token_str)
+        return if VALID_TOKEN_PREFIXES.any? { |prefix| token_str.start_with?(prefix) }
+
+        raise ArgumentError, 'invalid token format (must start with xoxb-, xoxc-, or xoxp-)'
+      end
+
+      def validate_cookie!(token_str, cookie_str)
+        if token_str.start_with?('xoxc-') && (cookie_str.nil? || cookie_str.strip.empty?)
+          raise ArgumentError, 'xoxc tokens require a cookie'
+        end
+        raise ArgumentError, 'cookie cannot contain newlines' if cookie_str&.match?(/[\r\n]/)
+      end
+    end
+  end
+end

data/lib/{slack_cli → slk}/runner.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
+  # Dependency injection container providing services to commands
   class Runner
     attr_reader :output, :config, :token_store, :api_client, :cache_store, :preset_store
 
+    # rubocop:disable Metrics/ParameterLists
     def initialize(
       output: nil,
       config: nil,
@@ -22,11 +24,12 @@ module SlackCli
       # Wire up warning callbacks to show warnings to users
       wire_up_warnings
     end
+    # rubocop:enable Metrics/ParameterLists
 
     # Workspace helpers
     def workspace(name = nil)
       name ||= @config.primary_workspace
-      raise ConfigError, "No workspace specified and no primary workspace configured" unless name
+      raise ConfigError, 'No workspace specified and no primary workspace configured' unless name
 
       @token_store.workspace(name)
     end
@@ -39,41 +42,41 @@ module SlackCli
       @token_store.workspace_names
     end
 
-    def has_workspaces?
+    def workspaces?
       !@token_store.empty?
     end
 
     # API helpers - create API instances bound to workspace
-    def users_api(ws = nil)
-      Api::Users.new(@api_client, workspace(ws), on_debug: ->(msg) { @output.debug(msg) })
+    def users_api(workspace_name = nil)
+      Api::Users.new(@api_client, workspace(workspace_name), on_debug: ->(msg) { @output.debug(msg) })
     end
 
-    def conversations_api(ws = nil)
-      Api::Conversations.new(@api_client, workspace(ws))
+    def conversations_api(workspace_name = nil)
+      Api::Conversations.new(@api_client, workspace(workspace_name))
     end
 
-    def dnd_api(ws = nil)
-      Api::Dnd.new(@api_client, workspace(ws))
+    def dnd_api(workspace_name = nil)
+      Api::Dnd.new(@api_client, workspace(workspace_name))
     end
 
-    def client_api(ws = nil)
-      Api::Client.new(@api_client, workspace(ws))
+    def client_api(workspace_name = nil)
+      Api::Client.new(@api_client, workspace(workspace_name))
     end
 
-    def emoji_api(ws = nil)
-      Api::Emoji.new(@api_client, workspace(ws))
+    def emoji_api(workspace_name = nil)
+      Api::Emoji.new(@api_client, workspace(workspace_name))
     end
 
-    def bots_api(ws = nil)
-      Api::Bots.new(@api_client, workspace(ws), on_debug: ->(msg) { @output.debug(msg) })
+    def bots_api(workspace_name = nil)
+      Api::Bots.new(@api_client, workspace(workspace_name), on_debug: ->(msg) { @output.debug(msg) })
     end
 
-    def threads_api(ws = nil)
-      Api::Threads.new(@api_client, workspace(ws))
+    def threads_api(workspace_name = nil)
+      Api::Threads.new(@api_client, workspace(workspace_name))
     end
 
-    def activity_api(ws = nil)
-      Api::Activity.new(@api_client, workspace(ws))
+    def activity_api(workspace_name = nil)
+      Api::Activity.new(@api_client, workspace(workspace_name))
     end
 
     # Formatter helpers