slk 0.1.0 → 0.2.0

data/lib/slk/commands/messages.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+require_relative '../support/help_formatter'
+require_relative '../support/inline_images'
+
+module Slk
+  module Commands
+    # Reads messages from channels, DMs, or threads
+    # rubocop:disable Metrics/ClassLength
+    class Messages < Base
+      include Support::InlineImages
+
+      def execute
+        result = validate_options
+        return result if result
+
+        target = positional_args.first
+        return missing_target_error unless target
+
+        resolved = target_resolver.resolve(target, default_workspace: target_workspaces.first)
+        fetch_and_display_messages(resolved)
+      rescue ApiError => e
+        error("Failed to fetch messages: #{e.message}")
+        1
+      end
+
+      def missing_target_error
+        error('Usage: slk messages <channel|@user|url>')
+        1
+      end
+
+      def fetch_and_display_messages(resolved)
+        apply_default_limit(resolved.msg_ts)
+        messages = fetch_messages(resolved.workspace, resolved.channel_id, resolved.thread_ts, oldest: resolved.msg_ts)
+        messages = enrich_reactions(messages, resolved.workspace, resolved.channel_id) if @options[:reaction_timestamps]
+
+        output_messages(messages, resolved.workspace, resolved.channel_id)
+        0
+      end
+
+      def output_messages(messages, workspace, channel_id)
+        if @options[:json]
+          output_json_messages(messages, workspace, channel_id)
+        else
+          display_messages(messages, workspace, channel_id)
+        end
+      end
+
+      protected
+
+      def default_options
+        super.merge(
+          limit: 500,
+          limit_set: false,
+          threads: false,
+          workspace_emoji: false
+        )
+      end
+
+      def handle_option(arg, args, remaining)
+        case arg
+        when '-n', '--limit' then handle_limit_option(args)
+        when '--threads' then @options[:threads] = true
+        when '--workspace-emoji' then @options[:workspace_emoji] = true
+        else super
+        end
+      end
+
+      def handle_limit_option(args)
+        @options[:limit] = args.shift.to_i
+        @options[:limit_set] = true
+      end
+
+      def help_text
+        help = Support::HelpFormatter.new('slk messages <target> [options]')
+        help.description('Read messages from a channel, DM, or thread.')
+        add_target_section(help)
+        add_options_section(help)
+        help.render
+      end
+
+      def add_target_section(help)
+        help.section('TARGET') do |s|
+          s.item('#channel', 'Channel by name')
+          s.item('channel', 'Channel by name (without #)')
+          s.item('@user', 'Direct message with user')
+          s.item('C123ABC', 'Channel by ID')
+          s.item('<slack_url>', 'Slack message URL (returns message + subsequent)')
+        end
+      end
+
+      def add_options_section(help)
+        help.section('OPTIONS') do |s|
+          add_message_options(s)
+          add_formatting_options(s)
+          add_common_options(s)
+        end
+      end
+
+      def add_message_options(section)
+        section.option('-n, --limit N', 'Number of messages (default: 500, or 50 for message URLs)')
+        section.option('--threads', 'Show thread replies inline')
+        section.option('--workspace-emoji', 'Show workspace emoji as inline images (experimental)')
+      end
+
+      def add_formatting_options(section)
+        section.option('--no-emoji', 'Show :emoji: codes instead of unicode')
+        section.option('--no-reactions', 'Hide reactions')
+        section.option('--no-names', 'Skip user name lookups (faster)')
+        section.option('--reaction-names', 'Show reactions with user names')
+        section.option('--reaction-timestamps', 'Show when each person reacted')
+        section.option('--width N', 'Wrap text at N columns (default: 72 on TTY, no wrap otherwise)')
+        section.option('--no-wrap', 'Disable text wrapping')
+      end
+
+      def add_common_options(section)
+        section.option('--json', 'Output as JSON')
+        section.option('-w, --workspace', 'Specify workspace')
+        section.option('-v, --verbose', 'Show debug information')
+        section.option('-q, --quiet', 'Suppress output')
+      end
+
+      private
+
+      def target_resolver
+        @target_resolver ||= Services::TargetResolver.new(runner: runner, cache_store: cache_store)
+      end
+
+      def enrich_reactions(messages, workspace, channel_id)
+        enricher = Services::ReactionEnricher.new(activity_api: runner.activity_api(workspace.name))
+        enricher.enrich_messages(messages, channel_id)
+      end
+
+      def output_json_messages(messages, workspace, channel_id)
+        format_options = {
+          no_names: @options[:no_names],
+          reaction_timestamps: @options[:reaction_timestamps],
+          channel_id: channel_id
+        }
+        output_json(messages.map do |m|
+          runner.message_formatter.format_json(m, workspace: workspace, options: format_options)
+        end)
+      end
+
+      # Apply default limit based on target type (50 for message URLs, 500 otherwise)
+      def apply_default_limit(msg_ts)
+        return if @options[:limit_set]
+
+        @options[:limit] = msg_ts ? 50 : 500
+      end
+
+      def fetch_messages(workspace, channel_id, thread_ts = nil, oldest: nil)
+        api = runner.conversations_api(workspace.name)
+        raw = if thread_ts
+                fetch_thread_messages(api, channel_id, thread_ts)
+              else
+                fetch_channel_history(api, channel_id, oldest)
+              end
+
+        raw.map { |m| Models::Message.from_api(m, channel_id: channel_id) }.reverse
+      end
+
+      def fetch_thread_messages(api, channel_id, thread_ts)
+        messages = fetch_all_thread_replies(api, channel_id, thread_ts)
+        apply_thread_limit(messages)
+      end
+
+      def apply_thread_limit(messages)
+        return messages unless @options[:limit].positive? && messages.length > @options[:limit]
+
+        [messages.first] + messages.last(@options[:limit] - 1)
+      end
+
+      def fetch_channel_history(api, channel_id, oldest)
+        oldest_adjusted = oldest ? adjust_timestamp(oldest, -0.000001) : nil
+        response = api.history(channel: channel_id, limit: @options[:limit], oldest: oldest_adjusted)
+        response['messages'] || []
+      end
+
+      # Adjust a Slack timestamp by a small amount while preserving precision
+      def adjust_timestamp(timestamp, delta)
+        require 'bigdecimal'
+        (BigDecimal(timestamp) + BigDecimal(delta.to_s)).to_s('F')
+      end
+
+      def fetch_all_thread_replies(api, channel_id, thread_ts)
+        all_messages = []
+        cursor = nil
+
+        loop do
+          response, cursor = fetch_thread_page(api, channel_id, thread_ts, cursor)
+          all_messages.concat(response)
+          break if cursor.nil? || cursor.empty?
+        end
+
+        deduplicate_and_sort(all_messages)
+      end
+
+      def fetch_thread_page(api, channel_id, thread_ts, cursor)
+        response = api.replies(channel: channel_id, timestamp: thread_ts, limit: 200, cursor: cursor)
+        messages = response['messages'] || []
+        debug("Fetched #{messages.length} messages")
+
+        next_cursor = response['has_more'] ? response.dig('response_metadata', 'next_cursor') : nil
+        [messages, next_cursor]
+      end
+
+      def deduplicate_and_sort(messages)
+        messages.uniq { |m| m['ts'] }.sort_by { |m| m['ts'].to_f }
+      end
+
+      def display_messages(messages, workspace, channel_id)
+        formatter = runner.message_formatter
+        opts = format_options.merge(channel_id: channel_id)
+
+        messages.each_with_index do |message, index|
+          display_single_message(formatter, message, workspace, opts)
+          puts if index < messages.length - 1
+
+          show_thread_replies(workspace, channel_id, message, opts) if should_show_thread?(message)
+        end
+      end
+
+      def should_show_thread?(message)
+        @options[:threads] && message.thread? && !message.reply?
+      end
+
+      def display_single_message(formatter, message, workspace, opts)
+        formatted = formatter.format(message, workspace: workspace, options: opts)
+        print_with_workspace_emoji(formatted, workspace)
+      end
+
+      def show_thread_replies(workspace, channel_id, parent_message, opts)
+        api = runner.conversations_api(workspace.name)
+        replies = fetch_all_thread_replies(api, channel_id, parent_message.ts)
+
+        replies[1..].each { |reply_data| display_thread_reply(reply_data, workspace, channel_id, opts) }
+      end
+
+      def display_thread_reply(reply_data, workspace, channel_id, opts)
+        reply = Models::Message.from_api(reply_data, channel_id: channel_id)
+        formatted = runner.message_formatter.format(reply, workspace: workspace, options: opts)
+
+        lines = formatted.lines
+        print_with_workspace_emoji("  └ #{lines.first}", workspace)
+        lines[1..].each { |line| print_with_workspace_emoji("    #{line}", workspace) }
+      end
+
+      # Print text, replacing workspace emoji codes with inline images when enabled
+      def print_with_workspace_emoji(text, workspace)
+        if @options[:workspace_emoji] && inline_images_supported?
+          print_line_with_emoji_images(text, workspace)
+        else
+          puts text
+        end
+      end
+
+      # Print a line, inserting inline images for workspace emoji
+      def print_line_with_emoji_images(text, workspace)
+        emoji_pattern = /:([a-zA-Z0-9_+-]+):/
+        parts = text.split(emoji_pattern)
+
+        parts.each_with_index { |part, i| print_emoji_part(part, i, workspace) }
+        puts
+      end
+
+      def print_emoji_part(part, index, workspace)
+        if index.odd?
+          print_emoji_or_code(part, workspace)
+        else
+          print part
+        end
+      end
+
+      def print_emoji_or_code(emoji_name, workspace)
+        emoji_path = find_workspace_emoji(workspace.name, emoji_name)
+        if emoji_path
+          print_inline_image(emoji_path, height: 1)
+          print ' ' unless in_tmux?
+        else
+          print ":#{emoji_name}:"
+        end
+      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
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/slk/commands/presence.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative '../support/help_formatter'
+
+module Slk
+  module Commands
+    # Gets or sets user presence (away/active)
+    class Presence < Base
+      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 ['away'] then set_presence('away')
+        in ['auto' | 'active'] then set_presence('auto')
+        in [] then get_presence
+        else unknown_presence
+        end
+      end
+
+      def unknown_presence
+        error("Unknown presence: #{positional_args.first}")
+        error('Valid options: away, auto, active')
+        1
+      end
+
+      protected
+
+      def help_text
+        help = Support::HelpFormatter.new('slk presence [away|auto|active]')
+        help.description('Get or set your presence status.')
+        help.note('GET shows all workspaces by default. SET applies to primary only.')
+        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 current presence (all workspaces)')
+          s.action('away', 'Set presence to away')
+          s.action('auto', 'Set presence to auto (active)')
+          s.action('active', 'Alias for auto')
+        end
+      end
+
+      def add_options_section(help)
+        help.section('OPTIONS') do |s|
+          s.option('-w, --workspace', 'Limit to specific workspace')
+          s.option('--all', 'Set across all workspaces')
+          s.option('-q, --quiet', 'Suppress output')
+        end
+      end
+
+      private
+
+      def get_presence # rubocop:disable Naming/AccessorMethodName
+        workspaces = @options[:workspace] ? [runner.workspace(@options[:workspace])] : runner.all_workspaces
+        workspaces.each { |workspace| display_workspace_presence(workspace, workspaces.size > 1) }
+        0
+      end
+
+      def display_workspace_presence(workspace, show_header)
+        data = runner.users_api(workspace.name).get_presence
+        puts output.bold(workspace.name) if show_header
+        puts "  Presence: #{format_presence_status(data[:presence], data[:manual_away])}"
+      end
+
+      def format_presence_status(presence, manual)
+        case [presence, manual]
+        in ['away', true] then output.yellow('away (manual)')
+        in ['away', _] then output.yellow('away')
+        in ['active', _] then output.green('active')
+        else presence
+        end
+      end
+
+      def set_presence(presence) # rubocop:disable Naming/AccessorMethodName
+        target_workspaces.each do |workspace|
+          runner.users_api(workspace.name).set_presence(presence)
+
+          status_text = presence == 'away' ? output.yellow('away') : output.green('active')
+          success("Presence set to #{status_text} 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
+  end
+end

data/lib/slk/commands/preset.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require_relative '../support/inline_images'
+require_relative '../support/help_formatter'
+
+module Slk
+  module Commands
+    # Manages and applies saved status presets
+    # rubocop:disable Metrics/ClassLength
+    class Preset < Base
+      include Support::InlineImages
+
+      def execute
+        result = validate_options
+        return result if result
+
+        dispatch_action
+      end
+
+      def dispatch_action
+        case positional_args
+        in ['list' | 'ls'] | [] then list_presets
+        in ['add'] then add_preset
+        in ['edit', name] then edit_preset(name)
+        in ['delete' | 'rm', name] then delete_preset(name)
+        in [name, *] then apply_preset(name)
+        end
+      end
+
+      protected
+
+      def help_text
+        help = Support::HelpFormatter.new('slk preset <action|name> [options]')
+        help.description('Manage and apply status presets.')
+        add_actions_section(help)
+        add_examples_section(help)
+        add_options_section(help)
+        help.render
+      end
+
+      def add_actions_section(help)
+        help.section('ACTIONS') do |s|
+          s.action('list', 'List all presets')
+          s.action('add', 'Add a new preset (interactive)')
+          s.action('edit <name>', 'Edit an existing preset')
+          s.action('delete <name>', 'Delete a preset')
+          s.action('<name>', 'Apply a preset')
+        end
+      end
+
+      def add_examples_section(help)
+        help.section('EXAMPLES') do |s|
+          s.example('slk preset list')
+          s.example('slk preset meeting')
+          s.example('slk preset add')
+        end
+      end
+
+      def add_options_section(help)
+        help.section('OPTIONS') do |s|
+          s.option('-w, --workspace', 'Specify workspace')
+          s.option('--all', 'Apply to all workspaces')
+          s.option('-q, --quiet', 'Suppress output')
+        end
+      end
+
+      private
+
+      def list_presets
+        presets = preset_store.all
+        return show_no_presets if presets.empty?
+
+        puts 'Presets:'
+        presets.each { |preset| display_preset(preset) }
+        0
+      end
+
+      def show_no_presets
+        puts 'No presets configured.'
+        0
+      end
+
+      def display_preset(preset)
+        puts "  #{output.bold(preset.name)}"
+        display_preset_status(preset) if preset_has_status?(preset)
+        display_preset_options(preset)
+      end
+
+      def preset_has_status?(preset)
+        !preset.text.empty? || !preset.emoji.empty?
+      end
+
+      def display_preset_options(preset)
+        puts "    Duration: #{preset.duration}" unless preset.duration == '0'
+        puts "    Presence: #{preset.presence}" if preset.sets_presence?
+        puts "    DND: #{preset.dnd}" if preset.sets_dnd?
+      end
+
+      def display_preset_status(preset)
+        emoji_name = preset.emoji.delete_prefix(':').delete_suffix(':')
+        emoji_path = find_workspace_emoji_any(emoji_name)
+
+        if emoji_path && inline_images_supported?
+          text = "    #{preset.text}"
+          print_inline_image_with_text(emoji_path, text)
+        else
+          puts "    #{preset.emoji} #{preset.text}"
+        end
+      end
+
+      def find_workspace_emoji_any(emoji_name)
+        return nil if emoji_name.empty?
+
+        paths = Support::XdgPaths.new
+        emoji_dir = config.emoji_dir || paths.cache_dir
+
+        # Search across all workspaces
+        runner.all_workspaces.each do |workspace|
+          workspace_dir = File.join(emoji_dir, workspace.name)
+          next unless Dir.exist?(workspace_dir)
+
+          path = Dir.glob(File.join(workspace_dir, "#{emoji_name}.*")).first
+          return path if path
+        end
+
+        nil
+      end
+
+      def add_preset
+        print 'Preset name: '
+        name = $stdin.gets&.chomp
+        return error('Name is required') if name.nil? || name.empty?
+
+        preset = prompt_for_preset_fields(name)
+        preset_store.add(preset)
+        success("Preset '#{name}' created")
+
+        0
+      end
+
+      def edit_preset(name)
+        existing = preset_store.get(name)
+        return error("Preset '#{name}' not found") unless existing
+
+        puts "Editing preset '#{name}' (press Enter to keep current value)"
+        preset = prompt_for_preset_fields(name, defaults: existing)
+        preset_store.add(preset)
+        success("Preset '#{name}' updated")
+
+        0
+      end
+
+      def prompt_for_preset_fields(name, defaults: nil)
+        Models::Preset.new(
+          name: name,
+          text: prompt_field('Status text', defaults&.text),
+          emoji: prompt_field('Emoji (e.g., :calendar:)', defaults&.emoji),
+          duration: prompt_field('Duration (e.g., 1h, 30m, or 0 for none)', defaults&.duration || '0'),
+          presence: prompt_field('Presence (away/auto or blank)', defaults&.presence),
+          dnd: prompt_field('DND (e.g., 1h, off, or blank)', defaults&.dnd)
+        )
+      end
+
+      def prompt_field(label, default = nil)
+        if default
+          print "#{label} [#{default}]: "
+          input = $stdin.gets&.chomp
+          input.empty? ? default : input
+        else
+          print "#{label}: "
+          $stdin.gets&.chomp || ''
+        end
+      end
+
+      def delete_preset(name)
+        return error("Preset '#{name}' not found") unless preset_store.exists?(name)
+
+        preset_store.remove(name)
+        success("Preset '#{name}' deleted")
+
+        0
+      end
+
+      def apply_preset(name)
+        preset = preset_store.get(name)
+        return error("Preset '#{name}' not found") unless preset
+
+        target_workspaces.each { |workspace| apply_preset_to_workspace(workspace, preset, name) }
+        0
+      rescue ApiError => e
+        error("Failed to apply preset: #{e.message}")
+        1
+      end
+
+      def apply_preset_to_workspace(workspace, preset, name)
+        apply_status(workspace, preset)
+        apply_presence(workspace, preset)
+        apply_dnd(workspace, preset)
+        success("Applied preset '#{name}' on #{workspace.name}")
+      end
+
+      def apply_status(workspace, preset)
+        users_api = runner.users_api(workspace.name)
+        if preset.clears_status?
+          users_api.clear_status
+        else
+          users_api.set_status(text: preset.text, emoji: preset.emoji, duration: preset.duration_value)
+        end
+      end
+
+      def apply_presence(workspace, preset)
+        return unless preset.sets_presence?
+
+        runner.users_api(workspace.name).set_presence(preset.presence)
+      end
+
+      def apply_dnd(workspace, preset)
+        return unless preset.sets_dnd?
+
+        dnd_api = runner.dnd_api(workspace.name)
+        if preset.dnd == 'off'
+          dnd_api.end_snooze
+        else
+          duration = Models::Duration.parse(preset.dnd)
+          dnd_api.set_snooze(duration)
+        end
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end