slk 0.1.0 → 0.2.0

data/lib/slk/commands/workspaces.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative '../support/help_formatter'
+
+module Slk
+  module Commands
+    # Manages configured Slack workspaces
+    # rubocop:disable Metrics/ClassLength
+    class Workspaces < Base
+      def execute
+        result = validate_options
+        return result if result
+
+        dispatch_action
+      end
+
+      def dispatch_action
+        case positional_args
+        in ['list'] | [] then list_workspaces
+        in ['add'] then add_workspace
+        in ['remove', name] then remove_workspace(name)
+        in ['primary'] then show_primary
+        in ['primary', name] then set_primary(name)
+        else unknown_action
+        end
+      end
+
+      def unknown_action
+        error("Unknown action: #{positional_args.first}")
+        1
+      end
+
+      protected
+
+      def help_text
+        help = Support::HelpFormatter.new('slk workspaces <action> [name]')
+        help.description('Manage Slack workspaces.')
+        add_actions_section(help)
+        add_options_section(help)
+        help.render
+      end
+
+      def add_actions_section(help)
+        help.section('ACTIONS') do |s|
+          s.action('list', 'List configured workspaces')
+          s.action('add', 'Add a new workspace (interactive)')
+          s.action('remove <name>', 'Remove a workspace')
+          s.action('primary', 'Show primary workspace')
+          s.action('primary <name>', 'Set primary workspace')
+        end
+      end
+
+      def add_options_section(help)
+        help.section('OPTIONS') do |s|
+          s.option('-q, --quiet', 'Suppress output')
+        end
+      end
+
+      private
+
+      def list_workspaces
+        names = runner.workspace_names
+        return show_no_workspaces if names.empty?
+
+        print_workspace_list(names, config.primary_workspace)
+        0
+      end
+
+      def show_no_workspaces
+        puts 'No workspaces configured.'
+        puts "Run 'slack workspaces add' to add one."
+        0
+      end
+
+      def print_workspace_list(names, primary)
+        puts 'Workspaces:'
+        names.each do |name|
+          marker = name == primary ? output.green('*') : ' '
+          puts "  #{marker} #{name}"
+        end
+      end
+
+      def add_workspace
+        name = prompt_for_name
+        return name if name.is_a?(Integer) # Error code
+
+        token, cookie = prompt_for_credentials
+        return token if token.is_a?(Integer) # Error code
+
+        save_workspace(name, token, cookie)
+      end
+
+      def prompt_for_name
+        print 'Workspace name: '
+        name = $stdin.gets&.chomp
+        return error('Name is required') if name.nil? || name.empty?
+        return error("Workspace '#{name}' already exists") if token_store.exists?(name)
+
+        name
+      end
+
+      def prompt_for_credentials
+        print 'Token (xoxb-... or xoxc-...): '
+        token = $stdin.gets&.chomp
+        return error('Token is required') if token.nil? || token.empty?
+
+        cookie = prompt_for_cookie(token)
+        [token, cookie]
+      end
+
+      def prompt_for_cookie(token)
+        return nil unless token.start_with?('xoxc-')
+
+        print 'Cookie (d=...): '
+        $stdin.gets&.chomp
+      end
+
+      def save_workspace(name, token, cookie)
+        token_store.add(name, token, cookie)
+
+        if runner.workspace_names.size == 1
+          config.primary_workspace = name
+          success("Added workspace '#{name}' (set as primary)")
+        else
+          success("Added workspace '#{name}'")
+        end
+        0
+      end
+
+      def remove_workspace(name)
+        return error("Workspace '#{name}' not found") unless token_store.exists?(name)
+
+        token_store.remove(name)
+        handle_primary_after_removal(name)
+        0
+      end
+
+      def handle_primary_after_removal(name)
+        return success("Removed workspace '#{name}'") unless config.primary_workspace == name
+
+        remaining = runner.workspace_names
+        if remaining.any?
+          config.primary_workspace = remaining.first
+          success("Removed workspace '#{name}'. Primary changed to '#{remaining.first}'")
+        else
+          config.primary_workspace = nil
+          success("Removed workspace '#{name}'")
+        end
+      end
+
+      def show_primary
+        primary = config.primary_workspace
+        puts primary ? "Primary workspace: #{primary}" : 'No primary workspace set.'
+        0
+      end
+
+      def set_primary(name) # rubocop:disable Naming/AccessorMethodName
+        return error("Workspace '#{name}' not found") unless token_store.exists?(name)
+
+        config.primary_workspace = name
+        success("Primary workspace set to '#{name}'")
+
+        0
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/slk/formatters/activity_formatter.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Slk
+  module Formatters
+    # Formats activity feed items for terminal display
+    # rubocop:disable Metrics/ClassLength
+    class ActivityFormatter
+      def initialize(output:, enricher:, emoji_replacer:, mention_replacer:, on_debug: nil)
+        @output = output
+        @enricher = enricher
+        @emoji = emoji_replacer
+        @mentions = mention_replacer
+        @on_debug = on_debug
+      end
+
+      # Display a list of activity items
+      def display_all(items, workspace, options: {})
+        return puts 'No activity found.' if items.empty?
+
+        items.each do |item|
+          display_item(item, workspace, options)
+        end
+      end
+
+      # Display a single activity item
+      def display_item(item, workspace, options)
+        type = item.dig('item', 'type')
+        timestamp = format_time(item['feed_ts'])
+        dispatch_activity_display(type, item, workspace, timestamp, options)
+      end
+
+      private
+
+      def dispatch_activity_display(type, item, workspace, timestamp, options)
+        case type
+        when 'message_reaction' then display_reaction(item, workspace, timestamp, options)
+        when 'at_user', 'at_user_group', 'at_channel', 'at_everyone'
+          display_mention(item, workspace, timestamp, options)
+        when 'thread_v2' then display_thread(item, workspace, timestamp, options)
+        when 'bot_dm_bundle' then display_bot_dm(item, workspace, timestamp, options)
+        else @on_debug&.call("Unknown activity type '#{type}' - skipping") if type
+        end
+      end
+
+      def display_reaction(item, workspace, timestamp, options)
+        reaction_data = item.dig('item', 'reaction')
+        message_data = item.dig('item', 'message')
+        return debug_missing('reaction') unless reaction_data && message_data
+
+        username = @enricher.resolve_user(workspace, reaction_data['user'])
+        emoji = @emoji.lookup_emoji(reaction_data['name']) || ":#{reaction_data['name']}:"
+        channel = @enricher.resolve_channel(workspace, message_data['channel'])
+
+        puts "#{@output.blue(timestamp)} #{@output.bold(username)} reacted #{emoji} in #{channel}"
+        show_message_preview(workspace, message_data, options)
+      end
+
+      def display_mention(item, workspace, timestamp, options)
+        message_data = item.dig('item', 'message')
+        return debug_missing('mention') unless message_data
+
+        user_id = message_data['author_user_id'] || message_data['user']
+        username = @enricher.resolve_user(workspace, user_id)
+        channel = @enricher.resolve_channel(workspace, message_data['channel'])
+
+        puts "#{@output.blue(timestamp)} #{@output.bold(username)} mentioned you in #{channel}"
+        show_message_preview(workspace, message_data, options)
+      end
+
+      def display_thread(item, workspace, timestamp, options)
+        thread_entry = item.dig('item', 'bundle_info', 'payload', 'thread_entry')
+        return debug_missing('thread') unless thread_entry
+
+        channel = @enricher.resolve_channel(workspace, thread_entry['channel_id'])
+        puts "#{@output.blue(timestamp)} Thread activity in #{channel}"
+
+        return unless options[:show_messages] && thread_entry['thread_ts']
+
+        message_data = { 'channel' => thread_entry['channel_id'], 'ts' => thread_entry['thread_ts'] }
+        show_message_preview(workspace, message_data, options)
+      end
+
+      def display_bot_dm(item, workspace, timestamp, options)
+        message_data = item.dig('item', 'bundle_info', 'payload', 'message')
+        return debug_missing('bot DM') unless message_data
+
+        channel = @enricher.resolve_channel(workspace, message_data['channel'])
+        puts "#{@output.blue(timestamp)} Bot message in #{channel}"
+        show_message_preview(workspace, message_data, options)
+      end
+
+      def show_message_preview(workspace, message_data, options)
+        return unless options[:show_messages]
+        return unless options[:fetch_message]
+
+        message = options[:fetch_message].call(workspace, message_data['channel'], message_data['ts'])
+        display_message_content(message, workspace) if message
+      end
+
+      def display_message_content(message, workspace)
+        username = resolve_message_author(message, workspace)
+        text = prepare_message_text(message, workspace)
+
+        lines = text.lines
+        first_line = truncate(lines.first&.strip || text, 100)
+        puts "  └─ #{username}: #{first_line}"
+
+        display_additional_lines(lines) if lines.length > 1
+      end
+
+      def resolve_message_author(message, workspace)
+        if message['user']
+          @enricher.resolve_user(workspace, message['user'])
+        elsif message['bot_id']
+          'Bot'
+        else
+          'Unknown'
+        end
+      end
+
+      def prepare_message_text(message, workspace)
+        text = message['text'] || ''
+        return '[No text]' if text.empty?
+
+        @mentions.replace(text, workspace)
+      end
+
+      def display_additional_lines(lines)
+        remaining = lines[1..2].map(&:strip).reject(&:empty?)
+        remaining.each { |line| puts "     #{truncate(line, 100)}" }
+        puts "     [#{lines.length - 3} more lines...]" if lines.length > 3
+      end
+
+      def truncate(text, max_length)
+        text.length > max_length ? "#{text[0..max_length]}..." : text
+      end
+
+      def format_time(slack_timestamp)
+        Time.at(slack_timestamp.to_f).strftime('%b %d %-I:%M %p')
+      end
+
+      def debug_missing(item_type)
+        @on_debug&.call("Could not display #{item_type} activity - missing data")
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/slk/formatters/attachment_formatter.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Slk
+  module Formatters
+    # Formats Slack message attachments for terminal display
+    class AttachmentFormatter
+      def initialize(output:, text_processor:)
+        @output = output
+        @text_processor = text_processor
+      end
+
+      def format(attachments, lines, options)
+        return if attachments.empty?
+        return if options[:no_attachments]
+
+        attachments.each { |att| format_attachment(att, lines, options) }
+      end
+
+      private
+
+      def format_attachment(attachment, lines, options)
+        att_text = attachment['text'] || attachment['fallback']
+        image_url = attachment['image_url'] || attachment['thumb_url']
+
+        return unless att_text || image_url
+
+        lines << ''
+        format_author(attachment, lines)
+        format_text(att_text, lines, options) if att_text
+        format_image(attachment, image_url, lines) if image_url
+      end
+
+      def format_author(attachment, lines)
+        author = attachment['author_name'] || attachment['author_subname']
+        lines << "> #{@output.bold(author)}:" if author
+      end
+
+      def format_text(att_text, lines, options)
+        processed_text = @text_processor.call(att_text)
+        processed_text = wrap_text(processed_text, options[:width])
+
+        processed_text.each_line do |line|
+          lines << "> #{line.chomp}"
+        end
+      end
+
+      def wrap_text(text, width)
+        return text unless width && width > 2
+
+        Support::TextWrapper.wrap(text, width - 2, width - 2)
+      end
+
+      def format_image(attachment, image_url, lines)
+        filename = attachment['title'] || extract_filename(image_url)
+        lines << "> [Image: #{filename}]"
+      end
+
+      def extract_filename(url)
+        File.basename(URI.parse(url).path)
+      rescue URI::InvalidURIError
+        'image'
+      end
+    end
+  end
+end

data/lib/slk/formatters/block_formatter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Slk
+  module Formatters
+    # Formats Slack Block Kit blocks for terminal display
+    class BlockFormatter
+      def initialize(text_processor:)
+        @text_processor = text_processor
+      end
+
+      def format(blocks, main_text, lines, options)
+        return unless blocks&.any?
+        return if options[:no_blocks]
+
+        block_texts = extract_texts(blocks)
+        block_texts = filter_duplicate_texts(block_texts, main_text)
+
+        return if block_texts.empty?
+
+        lines << ''
+        block_texts.each { |text| format_block_text(text, lines, options) }
+      end
+
+      private
+
+      def extract_texts(blocks)
+        return [] unless blocks.is_a?(Array)
+
+        blocks.filter_map do |block|
+          block.dig('text', 'text') if block['type'] == 'section'
+        end
+      end
+
+      def filter_duplicate_texts(block_texts, main_text)
+        normalized_main = normalize(main_text)
+        block_texts.reject { |bt| normalize(bt) == normalized_main }
+      end
+
+      def normalize(text)
+        text.to_s.gsub(/\s+/, ' ').strip.downcase
+      end
+
+      def format_block_text(block_text, lines, options)
+        processed = @text_processor.call(block_text)
+        processed = wrap_text(processed, options[:width])
+
+        processed.each_line { |line| lines << "> #{line.chomp}" }
+      end
+
+      def wrap_text(text, width)
+        return text unless width && width > 2
+
+        Support::TextWrapper.wrap(text, width - 2, width - 2)
+      end
+    end
+  end
+end

data/lib/{slack_cli → slk}/formatters/duration_formatter.rb

@@ -1,25 +1,26 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Formatters
+    # Formats Duration objects for display
     class DurationFormatter
       def format(duration)
-        return "" if duration.nil? || duration.zero?
+        return '' if duration.nil? || duration.zero?
 
         duration.to_s
       end
 
       def format_remaining(seconds)
-        return "" if seconds.nil? || seconds <= 0
+        return '' if seconds.nil? || seconds <= 0
 
         Models::Duration.new(seconds: seconds).to_s
       end
 
       def format_until(timestamp)
-        return "" if timestamp.nil? || timestamp <= 0
+        return '' if timestamp.nil? || timestamp <= 0
 
         remaining = timestamp - Time.now.to_i
-        return "expired" if remaining <= 0
+        return 'expired' if remaining <= 0
 
         format_remaining(remaining)
       end

data/lib/slk/formatters/emoji_replacer.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Slk
+  module Formatters
+    # Replaces :emoji: codes with unicode characters
+    class EmojiReplacer
+      EMOJI_REGEX = /:([a-zA-Z0-9_+-]+):/
+      SKIN_TONE_REGEX = /::skin-tone-(\d)/
+
+      # Common emoji mappings (subset - full list would be much larger)
+      EMOJI_MAP = {
+        # Faces
+        'smile' => "\u{1F604}", 'grinning' => "\u{1F600}", 'joy' => "\u{1F602}",
+        'rofl' => "\u{1F923}", 'smiley' => "\u{1F603}", 'sweat_smile' => "\u{1F605}",
+        'laughing' => "\u{1F606}", 'wink' => "\u{1F609}", 'blush' => "\u{1F60A}",
+        'yum' => "\u{1F60B}", 'sunglasses' => "\u{1F60E}", 'heart_eyes' => "\u{1F60D}",
+        'kissing_heart' => "\u{1F618}", 'thinking' => "\u{1F914}", 'thinking_face' => "\u{1F914}",
+        'raised_eyebrow' => "\u{1F928}", 'neutral_face' => "\u{1F610}", 'expressionless' => "\u{1F611}",
+        'unamused' => "\u{1F612}", 'rolling_eyes' => "\u{1F644}", 'grimacing' => "\u{1F62C}",
+        'relieved' => "\u{1F60C}", 'pensive' => "\u{1F614}", 'sleepy' => "\u{1F62A}",
+        'sleeping' => "\u{1F634}", 'sob' => "\u{1F62D}", 'cry' => "\u{1F622}",
+        'scream' => "\u{1F631}", 'angry' => "\u{1F620}", 'rage' => "\u{1F621}",
+
+        # Gestures
+        'wave' => "\u{1F44B}", '+1' => "\u{1F44D}", '-1' => "\u{1F44E}",
+        'thumbsup' => "\u{1F44D}", 'thumbsdown' => "\u{1F44E}",
+        'clap' => "\u{1F44F}", 'raised_hands' => "\u{1F64C}", 'pray' => "\u{1F64F}",
+        'point_up' => "\u{261D}", 'point_down' => "\u{1F447}", 'point_left' => "\u{1F448}",
+        'point_right' => "\u{1F449}", 'ok_hand' => "\u{1F44C}", 'v' => "\u{270C}",
+        'muscle' => "\u{1F4AA}", 'fist' => "\u{270A}",
+
+        # Hearts
+        'heart' => "\u{2764}", 'hearts' => "\u{2665}", 'yellow_heart' => "\u{1F49B}",
+        'green_heart' => "\u{1F49A}", 'blue_heart' => "\u{1F499}", 'purple_heart' => "\u{1F49C}",
+        'black_heart' => "\u{1F5A4}", 'broken_heart' => "\u{1F494}", 'sparkling_heart' => "\u{1F496}",
+
+        # Objects
+        'fire' => "\u{1F525}", 'star' => "\u{2B50}", 'sparkles' => "\u{2728}",
+        'boom' => "\u{1F4A5}", 'zap' => "\u{26A1}", 'sunny' => "\u{2600}",
+        'cloud' => "\u{2601}", 'umbrella' => "\u{2614}", 'snowflake' => "\u{2744}",
+        'rocket' => "\u{1F680}", 'airplane' => "\u{2708}", 'car' => "\u{1F697}",
+        'gift' => "\u{1F381}", 'trophy' => "\u{1F3C6}", 'medal' => "\u{1F3C5}",
+        'bell' => "\u{1F514}", 'key' => "\u{1F511}", 'lock' => "\u{1F512}",
+        'bulb' => "\u{1F4A1}", 'book' => "\u{1F4D6}", 'pencil' => "\u{270F}",
+        'memo' => "\u{1F4DD}", 'computer' => "\u{1F4BB}", 'phone' => "\u{1F4F1}",
+        'camera' => "\u{1F4F7}", 'headphones' => "\u{1F3A7}", 'microphone' => "\u{1F3A4}",
+
+        # Food
+        'coffee' => "\u{2615}", 'tea' => "\u{1F375}", 'beer' => "\u{1F37A}",
+        'wine_glass' => "\u{1F377}", 'pizza' => "\u{1F355}", 'hamburger' => "\u{1F354}",
+        'cake' => "\u{1F370}", 'cookie' => "\u{1F36A}", 'apple' => "\u{1F34E}",
+        'banana' => "\u{1F34C}", 'taco' => "\u{1F32E}", 'burrito' => "\u{1F32F}",
+        'knife_fork_plate' => "\u{1F37D}",
+
+        # Nature
+        'dog' => "\u{1F436}", 'cat' => "\u{1F431}", 'mouse' => "\u{1F42D}",
+        'rabbit' => "\u{1F430}", 'bear' => "\u{1F43B}", 'panda_face' => "\u{1F43C}",
+        'chicken' => "\u{1F414}", 'penguin' => "\u{1F427}", 'bird' => "\u{1F426}",
+        'fish' => "\u{1F41F}", 'bug' => "\u{1F41B}", 'bee' => "\u{1F41D}",
+        'rose' => "\u{1F339}", 'sunflower' => "\u{1F33B}", 'tree' => "\u{1F333}",
+        'cactus' => "\u{1F335}", 'palm_tree' => "\u{1F334}",
+
+        # Symbols
+        'white_check_mark' => "\u{2705}", 'heavy_check_mark' => "\u{2714}",
+        'x' => "\u{274C}", 'heavy_multiplication_x' => "\u{2716}",
+        'warning' => "\u{26A0}", 'no_entry' => "\u{26D4}", 'sos' => "\u{1F198}",
+        'question' => "\u{2753}", 'exclamation' => "\u{2757}", 'bangbang' => "\u{203C}",
+        '100' => "\u{1F4AF}", '1234' => "\u{1F522}",
+
+        # Status-related
+        'house' => "\u{1F3E0}", 'office' => "\u{1F3E2}", 'hospital' => "\u{1F3E5}",
+        'calendar' => "\u{1F4C5}", 'date' => "\u{1F4C5}", 'spiral_calendar' => "\u{1F5D3}",
+        'clock1' => "\u{1F550}", 'hourglass' => "\u{231B}", 'stopwatch' => "\u{23F1}",
+        'zzz' => "\u{1F4A4}", 'speech_balloon' => "\u{1F4AC}", 'thought_balloon' => "\u{1F4AD}",
+
+        # Common Slack custom
+        'party-blob' => "\u{1F389}", 'blob-wave' => "\u{1F44B}",
+        'tada' => "\u{1F389}", 'confetti_ball' => "\u{1F38A}",
+        'balloon' => "\u{1F388}", 'party_popper' => "\u{1F389}",
+        'eyes' => "\u{1F440}", 'eye' => "\u{1F441}",
+        'ear' => "\u{1F442}", 'nose' => "\u{1F443}",
+        'brb' => "\u{1F6B6}", 'away' => "\u{1F6B6}",
+        'test_tube' => "\u{1F9EA}"
+      }.freeze
+
+      def initialize(custom_emoji: {}, on_debug: nil)
+        @custom_emoji = custom_emoji
+        @on_debug = on_debug
+        @gemoji_cache = load_gemoji_cache
+      end
+
+      def replace(text, _workspace = nil)
+        result = text.dup
+
+        # Remove skin tone modifiers (we don't render them in terminal)
+        result.gsub!(SKIN_TONE_REGEX, '')
+
+        # Replace emoji codes
+        result.gsub!(EMOJI_REGEX) do
+          name = ::Regexp.last_match(1)
+          lookup_emoji(name) || ":#{name}:"
+        end
+
+        result
+      end
+
+      def lookup_emoji(name)
+        # Check custom emoji first
+        return nil if @custom_emoji[name] # Custom emoji are URLs, skip for now
+
+        # Check gemoji cache first (from sync-standard)
+        return @gemoji_cache[name] if @gemoji_cache&.key?(name)
+
+        # Fall back to built-in map
+        EMOJI_MAP[name]
+      end
+
+      def with_custom_emoji(emoji_hash)
+        self.class.new(custom_emoji: emoji_hash, on_debug: @on_debug)
+      end
+
+      private
+
+      def load_gemoji_cache
+        cache_path = gemoji_cache_path
+        return nil unless File.exist?(cache_path)
+
+        JSON.parse(File.read(cache_path))
+      rescue JSON::ParserError => e
+        @on_debug&.call("Failed to load gemoji cache: #{e.message}")
+        nil
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def gemoji_cache_path
+        File.join(ENV.fetch('XDG_CACHE_HOME', File.expand_path('~/.cache')), 'slk', 'gemoji.json')
+      end
+    end
+  end
+end