slk 0.1.0 → 0.2.0

data/lib/slk/commands/status.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require_relative '../support/inline_images'
+require_relative '../support/help_formatter'
+
+module Slk
+  module Commands
+    # Gets or sets user status text and emoji
+    # rubocop:disable Metrics/ClassLength
+    class Status < Base
+      include Support::InlineImages
+
+      def execute
+        result = validate_options
+        return result if result
+
+        dispatch_action
+      rescue ApiError => e
+        error("Failed: #{e.message}")
+        1
+      end
+
+      def dispatch_action
+        case positional_args
+        in ['clear', *] then clear_status
+        in [text, *rest] then set_status(text, rest)
+        in [] then get_status
+        end
+      end
+
+      protected
+
+      def default_options
+        super.merge(presence: nil, dnd: nil)
+      end
+
+      def handle_option(arg, args, remaining)
+        case arg
+        when '-p', '--presence'
+          @options[:presence] = args.shift
+        when '-d', '--dnd'
+          @options[:dnd] = args.shift
+        else
+          super
+        end
+      end
+
+      def help_text
+        help = Support::HelpFormatter.new('slk status [text] [emoji] [duration] [options]')
+        help.description('Get or set your Slack status.')
+        help.note('GET shows all workspaces by default. SET applies to primary only.')
+        add_examples_section(help)
+        add_options_section(help)
+        help.render
+      end
+
+      def add_examples_section(help)
+        help.section('EXAMPLES') do |s|
+          s.example('slk status', 'Show status (all workspaces)')
+          s.example('slk status clear', 'Clear status')
+          s.example('slk status "Working" :laptop:', 'Set status with emoji')
+          s.example('slk status "Meeting" :calendar: 1h', 'Set status for 1 hour')
+          s.example('slk status "Focus" :headphones: 2h -p away -d 2h')
+        end
+      end
+
+      def add_options_section(help)
+        help.section('OPTIONS') do |s|
+          s.option('-p, --presence VALUE', 'Also set presence (away/auto/active)')
+          s.option('-d, --dnd DURATION', "Also set DND (or 'off')")
+          s.option('-w, --workspace', 'Limit to specific workspace')
+          s.option('--all', 'Set across all workspaces')
+          s.option('-v, --verbose', 'Show debug information')
+          s.option('-q, --quiet', 'Suppress output')
+        end
+      end
+
+      private
+
+      def get_status # rubocop:disable Naming/AccessorMethodName
+        # GET defaults to all workspaces unless -w specified
+        workspaces = target_workspaces_for_get
+
+        workspaces.each do |workspace|
+          status = runner.users_api(workspace.name).get_status
+          print_workspace_status(workspaces, workspace, status)
+        end
+
+        0
+      end
+
+      def target_workspaces_for_get
+        @options[:workspace] ? [runner.workspace(@options[:workspace])] : runner.all_workspaces
+      end
+
+      def print_workspace_status(workspaces, workspace, status)
+        puts output.bold(workspace.name) if workspaces.size > 1
+
+        if status.empty?
+          puts '  (no status set)'
+        else
+          display_status(workspace, status)
+        end
+      end
+
+      def display_status(workspace, status)
+        emoji_path = workspace_emoji_path(workspace.name, status.emoji)
+
+        if emoji_path && inline_images_supported?
+          print_status_with_image(emoji_path, status)
+        else
+          puts "  #{status}"
+        end
+      end
+
+      def workspace_emoji_path(workspace_name, emoji)
+        emoji_name = emoji.delete_prefix(':').delete_suffix(':')
+        find_workspace_emoji(workspace_name, emoji_name)
+      end
+
+      def print_status_with_image(emoji_path, status)
+        parts = []
+        parts << status.text unless status.text.empty?
+        parts << "(#{status.time_remaining})" if status.time_remaining
+        print_inline_image_with_text(emoji_path, "  #{parts.join(' ')}")
+      end
+
+      def find_workspace_emoji(workspace_name, emoji_name)
+        return nil if emoji_name.empty?
+
+        paths = Support::XdgPaths.new
+        emoji_dir = config.emoji_dir || paths.cache_dir
+        workspace_dir = File.join(emoji_dir, workspace_name)
+        return nil unless Dir.exist?(workspace_dir)
+
+        # Look for emoji file with any extension
+        Dir.glob(File.join(workspace_dir, "#{emoji_name}.*")).first
+      end
+
+      def set_status(text, rest)
+        emoji = extract_emoji(rest)
+        duration = extract_duration(rest)
+
+        target_workspaces.each do |workspace|
+          apply_status_to_workspace(workspace, text, emoji, duration)
+        end
+
+        show_all_workspaces_hint
+        0
+      end
+
+      def extract_emoji(rest)
+        rest.find { |arg| arg.start_with?(':') && arg.end_with?(':') } || ':speech_balloon:'
+      end
+
+      def extract_duration(rest)
+        duration_str = rest.find { |arg| arg.match?(/^\d+[hms]?$/) }
+        duration_str ? Models::Duration.parse(duration_str) : Models::Duration.zero
+      end
+
+      def apply_status_to_workspace(workspace, text, emoji, duration)
+        api = runner.users_api(workspace.name)
+        api.set_status(text: text, emoji: emoji, duration: duration)
+
+        log_status_set(workspace.name, text, emoji, duration)
+        apply_presence(workspace) if @options[:presence]
+        apply_dnd(workspace) if @options[:dnd]
+      end
+
+      def log_status_set(workspace_name, text, emoji, duration)
+        success("Status set on #{workspace_name}")
+        debug("  Text: #{text}")
+        debug("  Emoji: #{emoji}")
+        debug("  Duration: #{duration}") unless duration.zero?
+      end
+
+      def apply_presence(workspace)
+        value = @options[:presence]
+        value = 'auto' if value == 'active'
+
+        api = runner.users_api(workspace.name)
+        api.set_presence(value)
+        success("Presence set to #{value} on #{workspace.name}")
+      end
+
+      def apply_dnd(workspace)
+        value = @options[:dnd]
+        dnd_api = runner.dnd_api(workspace.name)
+
+        if value == 'off'
+          dnd_api.end_snooze
+          success("DND disabled on #{workspace.name}")
+        else
+          duration = Models::Duration.parse(value)
+          dnd_api.set_snooze(duration)
+          success("DND enabled for #{value} on #{workspace.name}")
+        end
+      end
+
+      def clear_status
+        target_workspaces.each do |workspace|
+          api = runner.users_api(workspace.name)
+          api.clear_status
+
+          success("Status cleared on #{workspace.name}")
+        end
+
+        show_all_workspaces_hint
+
+        0
+      end
+
+      def show_all_workspaces_hint
+        # Show hint if user has multiple workspaces and didn't use --all or -w
+        return if @options[:all] || @options[:workspace]
+        return if runner.all_workspaces.size <= 1
+
+        info('Tip: Use --all to set across all workspaces')
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/slk/commands/thread.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'messages'
+
+module Slk
+  module Commands
+    # Views a message thread from a Slack URL
+    class Thread < Messages
+      def execute
+        result = validate_options
+        return result if result
+
+        target = positional_args.first
+        return usage_error unless target
+        return url_required_error unless Support::SlackUrlParser.new.slack_url?(target)
+
+        super
+      end
+
+      protected
+
+      def usage_error
+        error('Usage: slk thread <url>')
+        1
+      end
+
+      def url_required_error
+        error('thread command requires a Slack URL')
+        1
+      end
+
+      def default_options
+        super.merge(
+          limit: 1,
+          limit_set: true, # Prevent apply_default_limit from overriding
+          threads: true
+        )
+      end
+
+      def help_text
+        help = Support::HelpFormatter.new('slk thread <url> [options]')
+        help.description('View a message thread from a Slack URL.')
+        add_usage_section(help)
+        add_options_section(help)
+        add_examples_section(help)
+        help.render
+      end
+
+      private
+
+      def add_usage_section(help)
+        help.section('USAGE') { |s| s.item('<slack_url>', 'Slack message URL') }
+      end
+
+      def add_options_section(help)
+        help.section('OPTIONS') do |s|
+          s.option('--no-emoji', 'Show :emoji: codes instead of unicode')
+          s.option('--no-reactions', 'Hide reactions')
+          s.option('--no-names', 'Skip user name lookups (faster)')
+          s.option('--json', 'Output as JSON')
+          s.option('-v, --verbose', 'Show debug information')
+        end
+      end
+
+      def add_examples_section(help)
+        help.section('EXAMPLES') do |s|
+          s.item('slk thread https://work.slack.com/archives/C123/p1234567890', 'View thread')
+        end
+      end
+    end
+  end
+end

data/lib/slk/commands/unread.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+require_relative '../support/help_formatter'
+
+module Slk
+  module Commands
+    # Views and manages unread messages across workspaces
+    # rubocop:disable Metrics/ClassLength
+    class Unread < Base
+      include Support::UserResolver
+
+      def execute
+        result = validate_options
+        return result if result
+
+        dispatch_action
+      rescue ApiError => e
+        error("Failed: #{e.message}")
+        1
+      end
+
+      private
+
+      def dispatch_action
+        case positional_args
+        in ['clear', *rest] then clear_unread(rest.first)
+        in [] then show_unread
+        else unknown_action
+        end
+      end
+
+      def unknown_action
+        error("Unknown action: #{positional_args.first}")
+        1
+      end
+
+      protected
+
+      def default_options
+        super.merge(
+          all: true, # Default to all workspaces
+          muted: false,
+          limit: 10
+        )
+      end
+
+      def handle_option(arg, args, remaining)
+        case arg
+        when '--muted'
+          @options[:muted] = true
+        when '-n', '--limit'
+          @options[:limit] = args.shift.to_i
+        else
+          super
+        end
+      end
+
+      def help_text
+        help = Support::HelpFormatter.new('slk unread [action] [options]')
+        help.description('View and manage unread messages (all workspaces by default).')
+        add_actions_section(help)
+        add_options_section(help)
+        help.render
+      end
+
+      def add_actions_section(help)
+        help.section('ACTIONS') do |s|
+          s.action('(none)', 'Show unread messages')
+          s.action('clear', 'Mark all as read')
+          s.action('clear #channel', 'Mark specific channel as read')
+        end
+      end
+
+      def add_options_section(help)
+        help.section('OPTIONS') do |s|
+          add_core_options(s)
+          add_formatting_options(s)
+        end
+      end
+
+      def add_core_options(section)
+        section.option('-n, --limit N', 'Messages per channel (default: 10)')
+        section.option('--muted', 'Include/clear muted channels')
+        section.option('-w, --workspace', 'Limit to specific workspace')
+        section.option('--json', 'Output as JSON')
+        section.option('-q, --quiet', 'Suppress output')
+      end
+
+      def add_formatting_options(section)
+        section.option('--no-emoji', 'Show :emoji: codes instead of unicode')
+        section.option('--no-reactions', 'Hide reactions')
+        section.option('--reaction-names', 'Show reactions with user names')
+        section.option('--reaction-timestamps', 'Show when each person reacted')
+      end
+
+      private
+
+      def show_unread
+        target_workspaces.each do |workspace|
+          puts output.bold(workspace.name) if @options[:all] || target_workspaces.size > 1
+
+          unread_data = fetch_unread_data(workspace)
+
+          if @options[:json]
+            output_unread_json(workspace, unread_data)
+          else
+            display_unread(workspace, unread_data)
+          end
+        end
+
+        0
+      end
+
+      def fetch_unread_data(workspace)
+        counts = runner.client_api(workspace.name).counts
+        muted_ids = fetch_muted_ids(workspace)
+
+        {
+          unread_ims: filter_unread_ims(counts['ims'] || []),
+          unread_channels: filter_unread_channels(counts['channels'] || [], muted_ids)
+        }
+      end
+
+      def fetch_muted_ids(workspace)
+        @options[:muted] ? [] : runner.users_api(workspace.name).muted_channels
+      end
+
+      def filter_unread_ims(ims)
+        ims.select { |i| i['has_unreads'] }
+      end
+
+      def filter_unread_channels(channels, muted_ids)
+        channels
+          .select { |c| c['has_unreads'] || (c['mention_count'] || 0).positive? }
+          .reject { |c| muted_ids.include?(c['id']) }
+      end
+
+      def output_unread_json(workspace, data)
+        output_json({
+                      channels: data[:unread_channels].map { |c| format_channel_json(workspace, c) },
+                      dms: data[:unread_ims].map { |i| format_dm_json(workspace, i) }
+                    })
+      end
+
+      def format_channel_json(workspace, channel)
+        channel_hash = { id: channel['id'], mentions: channel['mention_count'] }
+        channel_name = cache_store.get_channel_name(workspace.name, channel['id'])
+        channel_hash[:name] = channel_name if channel_name
+        channel_hash
+      end
+
+      def format_dm_json(workspace, dm_item)
+        dm_hash = { id: dm_item['id'], mentions: dm_item['mention_count'] }
+        user_id = dm_item['user_id'] || dm_item['user']
+        if user_id
+          user_name = cache_store.get_user(workspace.name, user_id)
+          dm_hash[:user_name] = user_name if user_name
+        end
+        dm_hash
+      end
+
+      def display_unread(workspace, data)
+        conversations_api = runner.conversations_api(workspace.name)
+        formatter = runner.message_formatter
+
+        display_unread_dms(workspace, data[:unread_ims], conversations_api, formatter)
+        display_unread_channels(workspace, data[:unread_channels], conversations_api, formatter)
+        show_threads(workspace, formatter)
+      end
+
+      def display_unread_dms(workspace, unread_ims, conversations_api, formatter)
+        unread_ims.each do |im|
+          mention_count = im['mention_count'] || 0
+          user_name = resolve_dm_user_name(workspace, im['id'], conversations_api)
+          puts
+          puts output.bold("@#{user_name}") + (mention_count.positive? ? " (#{mention_count} mentions)" : '')
+          puts
+          show_channel_messages(workspace, im['id'], @options[:limit], conversations_api, formatter)
+        end
+      end
+
+      def display_unread_channels(workspace, unreads, conversations_api, formatter)
+        return puts('No unread messages') if unreads.empty?
+
+        unreads.each { |ch| display_channel(workspace, ch, conversations_api, formatter) }
+      end
+
+      def display_channel(workspace, channel, conversations_api, formatter)
+        name = cache_store.get_channel_name(workspace.name, channel['id']) || channel['id']
+        puts
+        puts "#{output.bold("##{name}")} (showing last #{@options[:limit]})"
+        puts
+        show_channel_messages(workspace, channel['id'], @options[:limit], conversations_api, formatter)
+      end
+
+      def show_threads(workspace, formatter)
+        threads_response = runner.threads_api(workspace.name).get_view(limit: 20)
+        return unless threads_response['ok']
+
+        total_unreads = threads_response['total_unread_replies'] || 0
+        return if total_unreads.zero?
+
+        print_threads_header(total_unreads)
+        (threads_response['threads'] || []).each { |t| display_thread(workspace, t, formatter) }
+      end
+
+      def print_threads_header(total_unreads)
+        puts
+        puts "#{output.bold('🧵 Threads')} (#{total_unreads} unread replies)"
+        puts
+      end
+
+      def display_thread(workspace, thread, formatter)
+        unread_replies = thread['unread_replies'] || []
+        return if unread_replies.empty?
+
+        print_thread_header(workspace, thread)
+        print_thread_replies(workspace, thread, unread_replies, formatter)
+        puts
+      end
+
+      def print_thread_header(workspace, thread)
+        root_msg = thread['root_msg'] || {}
+        channel_id = root_msg['channel']
+        conversation_label = resolve_conversation_label(workspace, channel_id)
+        root_user = extract_user_from_message(root_msg, workspace)
+
+        puts "#{output.blue("  #{conversation_label}")} - thread by #{output.bold(root_user)}"
+      end
+
+      def print_thread_replies(workspace, thread, unread_replies, formatter)
+        channel_id = (thread['root_msg'] || {})['channel']
+        unread_replies.first(@options[:limit]).each do |reply|
+          message = Models::Message.from_api(reply, channel_id: channel_id)
+          puts "    #{formatter.format_simple(message, workspace: workspace, options: format_options)}"
+        end
+      end
+
+      def show_channel_messages(workspace, channel_id, limit, api, formatter)
+        messages = fetch_channel_messages(workspace, channel_id, limit, api)
+        messages.each do |message|
+          puts formatter.format_simple(message, workspace: workspace, options: format_options)
+        end
+      rescue ApiError => e
+        puts output.dim("  (Could not fetch messages: #{e.message})")
+      end
+
+      def fetch_channel_messages(workspace, channel_id, limit, api)
+        history = api.history(channel: channel_id, limit: limit)
+        raw_messages = (history['messages'] || []).reverse
+        messages = raw_messages.map { |msg| Models::Message.from_api(msg, channel_id: channel_id) }
+
+        return messages unless @options[:reaction_timestamps]
+
+        enricher = Services::ReactionEnricher.new(activity_api: runner.activity_api(workspace.name))
+        enricher.enrich_messages(messages, channel_id)
+      end
+
+      def clear_unread(channel_name)
+        target_workspaces.each do |ws|
+          channel_name ? clear_single_channel(ws, channel_name) : clear_all_channels(ws)
+        end
+        0
+      end
+
+      def clear_single_channel(workspace, channel_name)
+        channel_id = resolve_channel_id(workspace, channel_name)
+        return unless unread_marker(workspace).mark_single_channel(channel_id)
+
+        success("Marked ##{channel_name} as read on #{workspace.name}")
+      end
+
+      def clear_all_channels(workspace)
+        counts = unread_marker(workspace).mark_all(options: { muted: @options[:muted] })
+        success("Cleared #{counts[:channels]} channels and #{counts[:threads]} threads on #{workspace.name}")
+      end
+
+      def unread_marker(workspace)
+        Services::UnreadMarker.new(
+          conversations_api: runner.conversations_api(workspace.name),
+          threads_api: runner.threads_api(workspace.name),
+          client_api: runner.client_api(workspace.name),
+          users_api: runner.users_api(workspace.name),
+          on_debug: ->(msg) { debug(msg) }
+        )
+      end
+
+      def resolve_channel_id(workspace, channel_name)
+        return channel_name if channel_name.match?(/^[CDG][A-Z0-9]+$/)
+
+        name = channel_name.delete_prefix('#')
+        cache_store.get_channel_id(workspace.name, name) || resolve_channel(workspace, name)
+      end
+
+      def resolve_channel(workspace, name)
+        api = runner.conversations_api(workspace.name)
+        response = api.list
+        channels = response['channels'] || []
+        channel = channels.find { |c| c['name'] == name }
+        channel&.dig('id') || raise(ConfigError, "Channel not found: ##{name}")
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end