slk 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd09692101d4658e57208d39e81d770e6dc36d2218088194ef55ad5fad0adbd0
-  data.tar.gz: 88e03a0be601536ffb3fd8f1b986900f8f57144b03a52ec5fa24b0b5dbdfbc57
+  metadata.gz: ef8284e736f39c42a65ef336e2d8db1a36f998393070433809db242cf6de0861
+  data.tar.gz: 6af8a0cdb8cbc5f35aea41e89ba0221cd0eb7ab5e4fbbf360cc60b2eb750c4d7
 SHA512:
-  metadata.gz: 399ca26d5d030704ad553e579fab75376db1578e0814f1ad8a9c2e4115c44e32c8173263fb39c8839eb7a0014ca1758d4e1aaa33b8d65353ba64e6fe83fa8efe
-  data.tar.gz: 64bfbe31c44af1961f43cd7f027bd352847af05434b957bbceb03e26c8bdf820ee805c1fb67d2adac80e18e7ddc286fd643572a17695209db1e3e7826c358baa
+  metadata.gz: 2c384f28530877909f82a596d4b306ca342989b5720f7cee47ea8157b91f59bd21202101c85e8878a83cb909a3ff954dec6dcabea8d3de2ae72c5d49e6f55882
+  data.tar.gz: 1da065c6704edfd5beaf45b2989a9fec1a183061109d5d167467943d7eecaf3b1f7c707e46ae4b517b2e28c3d1edcb23cf37d0f90fda1882408d362be59fc992

data/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- **Ghostty/Kitty terminal support** - Inline emoji images now work in Ghostty and Kitty terminals
+  - Uses Kitty graphics protocol with Unicode placeholders for proper tmux support
+  - Images clear correctly with `clear` command (no floating artifacts)
+  - Converts GIF/JPEG to PNG automatically (macOS only via `sips`)
+
+- **`later` command** - View Slack's "Save for Later" items
+  - Lists saved messages with content preview
+  - Filter by state: `--completed`, `--in-progress`
+  - `--counts` for summary statistics (total, overdue, with due dates)
+  - `--no-content` to skip fetching message text
+  - `--workspace-emoji` for inline custom emoji images
+  - `--width N` to wrap text at N columns
+  - `--no-wrap` to truncate messages to single line
+  - `--json` output includes message content
+
+### Changed
+
+- New `TextProcessor` service centralizes text processing (HTML decode, mentions, emoji)
+- New `MessageResolver` service extracted from activity command for reuse
+- Refactored formatters to use shared TextProcessor
+
 ## [0.4.0] - 2026-01-30
 
 ### Added

data/lib/slk/api/saved.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Slk
+  module Api
+    # Thin wrapper for the Slack saved.list API endpoint
+    # Used to fetch "Save for Later" items
+    class Saved
+      def initialize(api_client, workspace)
+        @api = api_client
+        @workspace = workspace
+      end
+
+      # List saved items
+      # @param filter [String] Filter type: 'saved', 'in_progress', 'completed', 'archived'
+      # @param limit [Integer] Number of items to return (default: 15)
+      # @param cursor [String, nil] Pagination cursor
+      # @return [Hash] API response with 'ok' and 'saved_items' keys
+      # @raise [ApiError] if the API call fails (network error, auth error, etc.)
+      def list(filter: 'saved', limit: 15, cursor: nil)
+        params = { filter: filter, limit: limit.to_s }
+        params[:cursor] = cursor if cursor
+        @api.post_form(@workspace, 'saved.list', params)
+      end
+    end
+  end
+end

data/lib/slk/cli.rb

@@ -13,6 +13,7 @@ module Slk
       'unread' => Commands::Unread,
       'catchup' => Commands::Catchup,
       'activity' => Commands::Activity,
+      'later' => Commands::Later,
       'search' => Commands::Search,
       'preset' => Commands::Preset,
       'workspaces' => Commands::Workspaces,
@@ -25,6 +26,7 @@ module Slk
     def initialize(argv, output: nil)
       @argv = argv.dup
       @output = output || Formatters::Output.new
+      @output_injected = !output.nil?
     end
 
     def run
@@ -118,13 +120,22 @@ module Slk
     def build_runner(args)
       verbose = verbose_mode?(args)
       very_verbose = args.include?('-vv') || args.include?('--very-verbose')
-      output = @output || Formatters::Output.new(verbose: verbose)
+      markdown = args.include?('--markdown')
+      output = @output_injected ? @output : build_output(verbose: verbose, markdown: markdown)
       runner = Runner.new(output: output)
       setup_verbose_logging(runner, output) if verbose
       setup_very_verbose_logging(runner, output) if very_verbose
       runner
     end
 
+    def build_output(verbose:, markdown:)
+      if markdown
+        Formatters::MarkdownOutput.new(verbose: verbose)
+      else
+        Formatters::Output.new(verbose: verbose)
+      end
+    end
+
     def setup_verbose_logging(runner, output)
       runner.api_client.on_request = lambda { |method, count|
         output.debug("[API ##{count}] #{method}")

data/lib/slk/commands/activity.rb

@@ -118,7 +118,7 @@ module Slk
           output: output,
           enricher: enricher(workspace),
           emoji_replacer: runner.emoji_replacer,
-          mention_replacer: runner.mention_replacer,
+          text_processor: runner.text_processor,
           on_debug: ->(msg) { debug(msg) }
         )
       end
@@ -131,20 +131,14 @@ module Slk
       end
 
       def fetch_message(workspace, channel_id, message_ts)
-        response = fetch_message_history(workspace, channel_id, message_ts)
-        return nil unless response['ok'] && response['messages']&.any?
-
-        response['messages'].find { |msg| msg['ts'] == message_ts }
-      rescue ApiError => e
-        debug("Could not fetch message #{message_ts} from #{channel_id}: #{e.message}")
-        nil
+        message_resolver(workspace).fetch_by_ts(channel_id, message_ts)
       end
 
-      def fetch_message_history(workspace, channel_id, message_ts)
-        api = runner.conversations_api(workspace.name)
-        oldest_ts = (message_ts.to_f - 1).to_s
-        latest_ts = (message_ts.to_f + 1).to_s
-        api.history(channel: channel_id, limit: 10, oldest: oldest_ts, latest: latest_ts)
+      def message_resolver(workspace)
+        Services::MessageResolver.new(
+          conversations_api: runner.conversations_api(workspace.name),
+          on_debug: ->(msg) { debug(msg) }
+        )
       end
     end
     # rubocop:enable Metrics/ClassLength

data/lib/slk/commands/base.rb

@@ -32,7 +32,7 @@ module Slk
       end
 
       def base_options
-        { workspace: nil, all: false, verbose: false, quiet: false, json: false, width: default_width }
+        { workspace: nil, all: false, verbose: false, quiet: false, json: false, markdown: false, width: default_width }
       end
 
       def formatting_options
@@ -72,6 +72,7 @@ module Slk
         when '-vv', '--very-verbose' then @options[:verbose] = @options[:very_verbose] = true
         when '-q', '--quiet' then @options[:quiet] = true
         when '--json' then @options[:json] = true
+        when '--markdown' then @options[:markdown] = true
         when '-h', '--help' then @options[:help] = true
         when '--no-emoji' then @options[:no_emoji] = true
         when '--no-reactions' then @options[:no_reactions] = true

data/lib/slk/commands/help.rb

@@ -45,6 +45,8 @@ module Slk
             #{output.cyan('messages')}     Read channel or DM messages
             #{output.cyan('search')}       Search messages across channels
             #{output.cyan('unread')}       View and clear unread messages
+            #{output.cyan('activity')}     Show activity feed (reactions, mentions, threads)
+            #{output.cyan('later')}        Show saved "Later" items
             #{output.cyan('preset')}       Manage and apply status presets
             #{output.cyan('workspaces')}   Manage Slack workspaces
             #{output.cyan('cache')}        Manage user/channel cache

data/lib/slk/commands/later.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+require 'stringio'
+require_relative '../support/help_formatter'
+
+module Slk
+  module Commands
+    # Displays saved "Later" items from Slack
+    # rubocop:disable Metrics/ClassLength
+    class Later < Base
+      include Support::InlineImages
+
+      def execute
+        result = validate_options
+        return result if result
+
+        workspace = target_workspaces.first
+        fetch_and_display_later_items(workspace)
+      rescue ApiError => e
+        error("Failed to fetch saved items: #{e.message}")
+        1
+      end
+
+      private
+
+      def fetch_and_display_later_items(workspace)
+        api = runner.saved_api(workspace.name)
+        response = api.list(filter: filter_type, limit: @options[:limit])
+
+        return error_result(response) unless response['ok']
+
+        items = parse_items(response['saved_items'] || [])
+        display_items(workspace, items)
+        0
+      end
+
+      def error_result(response)
+        error("Failed to fetch saved items: #{response['error']}")
+        1
+      end
+
+      def parse_items(items_data)
+        items_data.map { |data| Models::SavedItem.from_api(data) }
+      end
+
+      def filter_type
+        if @options[:completed]
+          'completed'
+        elsif @options[:in_progress]
+          'in_progress'
+        else
+          'saved'
+        end
+      end
+
+      def display_items(workspace, items)
+        if @options[:counts]
+          display_counts(items)
+        elsif @options[:json]
+          output_json(build_json_output(workspace, items))
+        else
+          display_formatted(workspace, items)
+        end
+      end
+
+      def display_counts(items)
+        puts "Total: #{items.size}"
+        puts "Overdue: #{items.count(&:overdue?)}" unless @options[:completed]
+        puts "With due dates: #{items.count(&:due_date?)}"
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def build_json_output(workspace, items)
+        items.map do |item|
+          json_item = {
+            channel_id: item.channel_id,
+            ts: item.ts,
+            state: item.state,
+            date_created: item.date_created,
+            date_due: item.date_due,
+            date_completed: item.date_completed,
+            overdue: item.overdue?
+          }
+
+          # Fetch message content unless --no-content
+          unless @options[:no_content]
+            message = fetch_message_content(workspace, item)
+            json_item[:message] = message if message
+          end
+
+          json_item
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # rubocop:disable Metrics/MethodLength
+      def display_formatted(workspace, items)
+        if items.empty?
+          puts 'No saved items found.'
+          return
+        end
+
+        @fetch_failures = 0
+        # Skip workspace emoji inline images in markdown mode (they're terminal escape sequences)
+        if @options[:workspace_emoji] && inline_images_supported? && !@options[:markdown]
+          display_with_workspace_emoji(workspace, items)
+        else
+          display_without_workspace_emoji(workspace, items)
+        end
+        show_fetch_failure_summary
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def display_without_workspace_emoji(workspace, items)
+        formatter = build_formatter(output)
+        items.each do |item|
+          message = @options[:no_content] ? nil : fetch_message_content(workspace, item)
+          formatter.display_item(item, workspace, message: message, width: display_width, truncate: @options[:truncate])
+        end
+      end
+
+      def display_with_workspace_emoji(workspace, items)
+        # Capture output to StringIO, then reprint with workspace emoji
+        buffer = StringIO.new
+        buffer_output = create_buffer_output(buffer)
+        formatter = build_formatter(buffer_output)
+
+        items.each do |item|
+          message = @options[:no_content] ? nil : fetch_message_content(workspace, item)
+          formatter.display_item(item, workspace, message: message, width: display_width, truncate: @options[:truncate])
+        end
+
+        # Reprint each line with workspace emoji replacement
+        buffer.string.each_line { |line| print_with_workspace_emoji(line.chomp, workspace) }
+      end
+
+      def show_fetch_failure_summary
+        return if @fetch_failures.zero?
+
+        output.puts output.gray("Note: Could not load content for #{@fetch_failures} item(s). Use -v for details.")
+      end
+
+      def display_width
+        @options[:width]
+      end
+
+      def build_formatter(out)
+        Formatters::SavedItemFormatter.new(
+          output: out,
+          mention_replacer: runner.mention_replacer,
+          text_processor: runner.text_processor,
+          on_debug: ->(msg) { debug(msg) }
+        )
+      end
+
+      # Create a buffer output using the same class as the main output
+      # This ensures markdown mode works correctly with workspace emoji buffering
+      def create_buffer_output(buffer)
+        if @options[:markdown]
+          Formatters::MarkdownOutput.new(io: buffer, err: $stderr)
+        else
+          Formatters::Output.new(io: buffer, err: $stderr, color: $stdout.tty?)
+        end
+      end
+
+      def fetch_message_content(workspace, item)
+        return nil unless item.ts && item.channel_id
+
+        result = message_resolver(workspace).fetch_by_ts(item.channel_id, item.ts)
+        @fetch_failures += 1 if result.nil?
+        result
+      end
+
+      def message_resolver(workspace)
+        Services::MessageResolver.new(
+          conversations_api: runner.conversations_api(workspace.name),
+          on_debug: ->(msg) { debug(msg) }
+        )
+      end
+
+      protected
+
+      def default_options
+        super.merge(
+          limit: 15,
+          completed: false,
+          in_progress: false,
+          counts: false,
+          no_content: false,
+          truncate: false,
+          workspace_emoji: false
+        )
+      end
+
+      def handle_option(arg, args, remaining)
+        case arg
+        when '-n', '--limit' then @options[:limit] = args.shift.to_i
+        when '--completed' then @options[:completed] = true
+        when '--in-progress' then @options[:in_progress] = true
+        when '--counts' then @options[:counts] = true
+        when '--no-content' then @options[:no_content] = true
+        when '--workspace-emoji' then @options[:workspace_emoji] = true
+        else super
+        end
+      end
+
+      # Override to intercept --no-wrap before base class handles it
+      def parse_single_option(arg, args, remaining)
+        if arg == '--no-wrap'
+          @options[:truncate] = true
+          @options[:width] ||= 140
+        else
+          super
+        end
+      end
+
+      def default_width
+        nil
+      end
+
+      def help_text
+        help = Support::HelpFormatter.new('slk later [options]')
+        help.description('Show saved "Later" items from Slack.')
+        add_options_section(help)
+        help.render
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def add_options_section(help)
+        help.section('OPTIONS') do |s|
+          s.option('-n, --limit N', 'Number of items (default: 15)')
+          s.option('--completed', 'Show completed items instead')
+          s.option('--in-progress', 'Show in-progress items')
+          s.option('--counts', 'Show summary counts only')
+          s.option('--no-content', 'Skip fetching message text')
+          s.option('--workspace-emoji', 'Show workspace emoji as inline images')
+          s.option('--no-emoji', 'Show :emoji: codes instead of unicode')
+          s.option('--width N', 'Wrap text at N columns')
+          s.option('--no-wrap', 'Truncate to single line instead of wrapping')
+          add_common_options(s)
+        end
+      end
+
+      # rubocop:enable Metrics/MethodLength
+
+      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
+
+      # Print text, replacing workspace emoji codes with inline images
+      def print_with_workspace_emoji(text, workspace)
+        print_line_with_emoji_images(text, workspace)
+      end
+
+      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)
+
+        Dir.glob(File.join(workspace_dir, "#{emoji_name}.*")).first
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/slk/commands/messages.rb

@@ -192,10 +192,10 @@ module Slk
         raw = if thread_ts
                 fetch_thread_messages(api, channel_id, thread_ts)
               else
-                fetch_channel_history(api, channel_id, oldest)
+                fetch_channel_history(api, channel_id, oldest).reverse
               end
 
-        raw.map { |m| Models::Message.from_api(m, channel_id: channel_id) }.reverse
+        raw.map { |m| Models::Message.from_api(m, channel_id: channel_id) }
       end
 
       def fetch_thread_messages(api, channel_id, thread_ts)
@@ -295,8 +295,9 @@ module Slk
       end
 
       # Print text, replacing workspace emoji codes with inline images when enabled
+      # Skip inline images in markdown mode (they're terminal escape sequences)
       def print_with_workspace_emoji(text, workspace)
-        if @options[:workspace_emoji] && inline_images_supported?
+        if @options[:workspace_emoji] && inline_images_supported? && !@options[:markdown]
           print_line_with_emoji_images(text, workspace)
         else
           puts text

data/lib/slk/formatters/activity_formatter.rb

@@ -5,11 +5,11 @@ module Slk
     # Formats activity feed items for terminal display
     # rubocop:disable Metrics/ClassLength
     class ActivityFormatter
-      def initialize(output:, enricher:, emoji_replacer:, mention_replacer:, on_debug: nil)
+      def initialize(output:, enricher:, emoji_replacer:, text_processor:, on_debug: nil)
         @output = output
         @enricher = enricher
         @emoji = emoji_replacer
-        @mentions = mention_replacer
+        @text_processor = text_processor
         @on_debug = on_debug
       end
 
@@ -119,10 +119,7 @@ module Slk
       end
 
       def prepare_message_text(message, workspace)
-        text = message['text'] || ''
-        return '[No text]' if text.empty?
-
-        @mentions.replace(text, workspace)
+        @text_processor.process(message['text'], workspace)
       end
 
       def display_additional_lines(lines)
@@ -136,7 +133,7 @@ module Slk
       end
 
       def format_time(slack_timestamp)
-        Time.at(slack_timestamp.to_f).strftime('%b %d %-I:%M %p')
+        Time.at(slack_timestamp.to_f).strftime('%b %d %-I:%M:%S %p')
       end
 
       def debug_missing(item_type)

data/lib/slk/formatters/markdown_output.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Slk
+  module Formatters
+    # Markdown output adapter with same interface as Output
+    # Produces markdown formatting instead of ANSI colors
+    class MarkdownOutput
+      attr_reader :verbose, :quiet
+
+      # Accept color: parameter for interface compatibility with Output (ignored for markdown)
+      def initialize(io: $stdout, err: $stderr, color: nil, verbose: false, quiet: false) # rubocop:disable Lint/UnusedMethodArgument
+        @io = io
+        @err = err
+        @verbose = verbose
+        @quiet = quiet
+      end
+
+      def puts(message = '')
+        @io.puts(message) unless @quiet
+      end
+
+      def print(message)
+        @io.print(message) unless @quiet
+      end
+
+      def error(message)
+        @err.puts("**Error:** #{message}")
+      end
+
+      def warn(message)
+        @err.puts("*Warning:* #{message}") unless @quiet
+      end
+
+      def success(message)
+        puts("✓ #{message}")
+      end
+
+      def info(message)
+        puts(message)
+      end
+
+      def debug(message)
+        return unless @verbose
+
+        @err.puts("*[debug]* #{message}")
+      end
+
+      # Markdown formatting helpers - string interpolation handles nil conversion
+      # bold -> **text**
+      def bold(text)
+        "**#{text}**"
+      end
+
+      # red -> **text** (emphasis for errors)
+      def red(text)
+        "**#{text}**"
+      end
+
+      # green -> plain text (success doesn't need markup)
+      def green(text)
+        text.to_s
+      end
+
+      # yellow -> *text* (italics for warnings)
+      def yellow(text)
+        "*#{text}*"
+      end
+
+      # blue -> `text` (code for timestamps)
+      def blue(text)
+        "`#{text}`"
+      end
+
+      # magenta -> *text* (italics for secondary)
+      def magenta(text)
+        "*#{text}*"
+      end
+
+      # cyan -> `text` (code for metadata like timestamps)
+      def cyan(text)
+        "`#{text}`"
+      end
+
+      # gray -> *text* (italics for secondary info)
+      def gray(text)
+        "*#{text}*"
+      end
+
+      def with_verbose(value)
+        self.class.new(io: @io, err: @err, verbose: value, quiet: @quiet)
+      end
+
+      def with_quiet(value)
+        self.class.new(io: @io, err: @err, verbose: @verbose, quiet: value)
+      end
+    end
+  end
+end