slk 0.2.0 → 0.4.1

data/lib/slk/services/token_store.rb

@@ -1,118 +1,88 @@
 # frozen_string_literal: true
 
+require_relative 'token_loader'
+require_relative 'token_saver'
+
 module Slk
   module Services
     # Manages workspace tokens with optional encryption
     class TokenStore
-      attr_accessor :on_warning
+      attr_accessor :on_warning, :on_info, :on_prompt_pub_key
 
       def initialize(config: nil, encryption: nil, paths: nil)
         @config = config || Configuration.new
         @encryption = encryption || Encryption.new
         @paths = paths || Support::XdgPaths.new
+        @loader = TokenLoader.new(encryption: @encryption, paths: @paths)
+        @saver = TokenSaver.new(encryption: @encryption, paths: @paths)
         @on_warning = nil
+        @on_info = nil
+        @on_prompt_pub_key = nil
       end
 
       def workspace(name)
-        tokens = load_tokens
+        tokens = @loader.load_auto(@config)
         data = tokens[name]
         raise WorkspaceNotFoundError, "Workspace '#{name}' not found" unless data
 
-        Models::Workspace.new(
-          name: name,
-          token: data['token'],
-          cookie: data['cookie']
-        )
+        Models::Workspace.new(name: name, token: data['token'], cookie: data['cookie'])
       end
 
       def all_workspaces
-        load_tokens.map do |name, data|
-          Models::Workspace.new(
-            name: name,
-            token: data['token'],
-            cookie: data['cookie']
-          )
+        @loader.load_auto(@config).map do |name, data|
+          Models::Workspace.new(name: name, token: data['token'], cookie: data['cookie'])
         end
       end
 
       def workspace_names
-        load_tokens.keys
+        @loader.load_auto(@config).keys
       end
 
       def exists?(name)
-        load_tokens.key?(name)
+        @loader.load_auto(@config).key?(name)
       end
 
       def add(name, token, cookie = nil)
-        # Validate by constructing a Workspace (will raise ArgumentError if invalid)
         Models::Workspace.new(name: name, token: token, cookie: cookie)
-
-        tokens = load_tokens
+        tokens = @loader.load_auto(@config)
         tokens[name] = { 'token' => token, 'cookie' => cookie }.compact
-        save_tokens(tokens)
+        @saver.save(tokens, @config.ssh_key)
       end
 
       def remove(name) # rubocop:disable Naming/PredicateMethod
-        tokens = load_tokens
+        tokens = @loader.load_auto(@config)
         removed = tokens.delete(name)
-        save_tokens(tokens) if removed
+        @saver.save(tokens, @config.ssh_key) if removed
         !removed.nil?
       end
 
       def empty?
-        load_tokens.empty?
+        @loader.load_auto(@config).empty?
       end
 
-      private
+      def migrate_encryption(old_ssh_key, new_ssh_key)
+        return if old_ssh_key == new_ssh_key
 
-      def load_tokens
-        if encrypted_file_exists?
-          decrypt_tokens
-        elsif plain_file_exists?
-          JSON.parse(File.read(plain_tokens_file))
-        else
-          {}
-        end
-      rescue JSON::ParserError => e
-        raise TokenStoreError, "Tokens file #{plain_tokens_file} is corrupted: #{e.message}"
+        tokens = @loader.load(old_ssh_key)
+        return if tokens.empty?
+
+        @encryption.on_prompt_pub_key = @on_prompt_pub_key
+        @encryption.validate_key_type!(new_ssh_key) if new_ssh_key
+        @saver.save_with_cleanup(tokens, new_ssh_key)
+        notify_encryption_change(old_ssh_key, new_ssh_key)
       end
 
-      def save_tokens(tokens)
-        @paths.ensure_config_dir
+      private
 
-        if @config.ssh_key
-          # When encryption is configured, always use it - don't silently fall back
-          @encryption.encrypt(JSON.generate(tokens), @config.ssh_key, encrypted_tokens_file)
-          FileUtils.rm_f(plain_tokens_file)
+      def notify_encryption_change(old_ssh_key, new_ssh_key)
+        if new_ssh_key && old_ssh_key
+          @on_info&.call('Tokens have been re-encrypted with the new SSH key.')
+        elsif new_ssh_key
+          @on_info&.call('Tokens have been encrypted with the new SSH key.')
         else
-          # Plain text storage (no encryption configured)
-          File.write(plain_tokens_file, JSON.pretty_generate(tokens))
-          File.chmod(0o600, plain_tokens_file)
+          @on_warning&.call('Tokens are now stored in plaintext.')
         end
       end
-
-      def decrypt_tokens
-        content = @encryption.decrypt(encrypted_tokens_file, @config.ssh_key)
-        content ? JSON.parse(content) : {}
-      rescue JSON::ParserError => e
-        raise TokenStoreError, "Encrypted tokens file is corrupted: #{e.message}"
-      end
-
-      def encrypted_file_exists?
-        File.exist?(encrypted_tokens_file)
-      end
-
-      def plain_file_exists?
-        File.exist?(plain_tokens_file)
-      end
-
-      def encrypted_tokens_file
-        @paths.config_file('tokens.age')
-      end
-
-      def plain_tokens_file
-        @paths.config_file('tokens.json')
-      end
     end
   end
 end

data/lib/slk/services/user_lookup.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Consolidated service for user name resolution
+    # Provides ID → name and name → ID lookups with caching
+    class UserLookup
+      def initialize(cache_store:, workspace:, api_client: nil, on_debug: nil)
+        @cache = cache_store
+        @api = api_client
+        @workspace = workspace
+        @on_debug = on_debug
+      end
+
+      # Resolve user ID to display name (most common use case)
+      # @param user_id [String] Slack user ID (e.g., "U123ABC")
+      # @return [String, nil] Display name or nil if not found
+      def resolve_name(user_id)
+        return nil if user_id.to_s.empty?
+
+        cached = @cache.get_user(@workspace.name, user_id)
+        return cached if cached
+
+        fetch_and_cache_name(user_id)
+      end
+
+      # Resolve user ID to display name, handling bots
+      # @param user_id [String] Slack user or bot ID
+      # @return [String, nil] Display name or nil if not found
+      def resolve_name_or_bot(user_id)
+        return nil if user_id.to_s.empty?
+
+        cached = @cache.get_user(@workspace.name, user_id)
+        return cached if cached
+
+        if user_id.start_with?('B')
+          fetch_and_cache_bot_name(user_id)
+        else
+          fetch_and_cache_name(user_id)
+        end
+      end
+
+      # Find user ID by display name (reverse lookup)
+      # @param name [String] Display name to search for
+      # @return [String, nil] User ID or nil if not found
+      def find_id_by_name(name)
+        return nil if name.to_s.empty?
+
+        cached = @cache.get_user_id_by_name(@workspace.name, name)
+        return cached if cached
+
+        fetch_id_by_name(name)
+      end
+
+      private
+
+      def fetch_and_cache_name(user_id)
+        return nil unless @api
+
+        user = fetch_user(user_id)
+        return nil unless user
+
+        @cache.set_user(@workspace.name, user_id, user.best_name, persist: true)
+        user.best_name
+      rescue ApiError => e
+        @on_debug&.call("User lookup failed for #{user_id}: #{e.message}")
+        nil
+      end
+
+      def fetch_and_cache_bot_name(bot_id)
+        return nil unless @api
+
+        bots_api = Api::Bots.new(@api, @workspace, on_debug: @on_debug)
+        name = bots_api.get_name(bot_id)
+        @cache.set_user(@workspace.name, bot_id, name, persist: true) if name
+        name
+      rescue ApiError => e
+        @on_debug&.call("Bot lookup failed for #{bot_id}: #{e.message}")
+        nil
+      end
+
+      def fetch_user(user_id)
+        users_api = Api::Users.new(@api, @workspace, on_debug: @on_debug)
+        response = users_api.info(user_id)
+        return nil unless response['ok'] && response['user']
+
+        Models::User.from_api(response['user'])
+      end
+
+      def fetch_id_by_name(name)
+        return nil unless @api
+
+        users_api = Api::Users.new(@api, @workspace, on_debug: @on_debug)
+        users = users_api.list['members'] || []
+        user = find_user_by_name(users, name)
+        cache_user_from_api(user) if user
+        user&.dig('id')
+      rescue ApiError => e
+        @on_debug&.call("User list lookup failed: #{e.message}")
+        nil
+      end
+
+      def find_user_by_name(users, name)
+        users.find do |u|
+          u['name'] == name ||
+            u.dig('profile', 'display_name') == name ||
+            u.dig('profile', 'real_name') == name
+        end
+      end
+
+      def cache_user_from_api(user_data)
+        user = Models::User.from_api(user_data)
+        @cache.set_user(@workspace.name, user.id, user.best_name, persist: true)
+      end
+    end
+  end
+end

data/lib/slk/support/date_parser.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Slk
+  module Support
+    # Parses date strings into timestamps for Slack API queries
+    # Supports duration formats (1d, 7d, 1w, 1m) and ISO dates (YYYY-MM-DD)
+    class DateParser
+      DURATION_PATTERN = /\A(\d+)([dwm])\z/i
+      ISO_DATE_PATTERN = /\A\d{4}-\d{2}-\d{2}\z/
+
+      # Parse a date string and return a Unix timestamp
+      # @param input [String] duration (1d, 7d, 1w, 1m) or ISO date (YYYY-MM-DD)
+      # @return [Integer] Unix timestamp
+      # @raise [ArgumentError] if format is invalid
+      def self.parse(input)
+        new.parse(input)
+      end
+
+      # Parse a date string and return a Slack-formatted timestamp (with microseconds)
+      # @param input [String] duration or ISO date
+      # @return [String] Slack timestamp like "1234567890.000000"
+      def self.to_slack_timestamp(input)
+        "#{parse(input)}.000000"
+      end
+
+      def parse(input)
+        input = input.to_s.strip
+
+        case input
+        when DURATION_PATTERN
+          parse_duration(input)
+        when ISO_DATE_PATTERN
+          parse_iso_date(input)
+        else
+          raise ArgumentError, "Invalid date format: #{input}. Use duration (1d, 7d, 1w, 1m) or ISO date (YYYY-MM-DD)"
+        end
+      end
+
+      private
+
+      def parse_duration(input)
+        match = input.match(DURATION_PATTERN)
+        amount = match[1].to_i
+        unit = match[2].downcase
+
+        seconds_ago = case unit
+                      when 'd' then amount * 86_400        # days
+                      when 'w' then amount * 7 * 86_400    # weeks
+                      when 'm' then amount * 30 * 86_400   # months (approximate)
+                      end
+
+        Time.now.to_i - seconds_ago
+      end
+
+      def parse_iso_date(input)
+        Time.parse("#{input} 00:00:00").to_i
+      rescue ArgumentError
+        raise ArgumentError, "Invalid ISO date: #{input}"
+      end
+    end
+  end
+end

data/lib/slk/support/inline_images.rb

@@ -2,11 +2,17 @@
 
 module Slk
   module Support
-    # Shared module for inline image display in iTerm2/WezTerm/Mintty terminals
+    # Shared module for inline image display in terminals supporting
+    # iTerm2 protocol (iTerm2/WezTerm/Mintty) or Kitty graphics protocol (Ghostty/Kitty)
     # Includes special handling for tmux passthrough sequences
     module InlineImages
-      # Check if terminal supports iTerm2 inline image protocol
+      # Check if terminal supports any inline image protocol
       def inline_images_supported?
+        iterm2_protocol_supported? || kitty_graphics_supported?
+      end
+
+      # Check if terminal supports iTerm2 inline image protocol
+      def iterm2_protocol_supported?
         # iTerm2, WezTerm, Mintty support inline images
         # LC_TERMINAL persists through tmux/ssh
         ['iTerm.app', 'WezTerm'].include?(ENV.fetch('TERM_PROGRAM', nil)) ||
@@ -15,31 +21,88 @@ module Slk
           ENV['TERM'] == 'mintty'
       end
 
+      # Check if terminal supports Kitty graphics protocol (Ghostty, Kitty)
+      def kitty_graphics_supported?
+        ENV['TERM_PROGRAM'] == 'ghostty' ||
+          ENV['GHOSTTY_RESOURCES_DIR'] ||
+          ENV['TERM']&.include?('kitty') ||
+          tmux_client_is_kitty_compatible?
+      end
+
+      # Check if tmux client terminal supports Kitty graphics
+      def tmux_client_is_kitty_compatible?
+        return false unless in_tmux?
+
+        @tmux_client_is_kitty_compatible ||= begin
+          output = begin
+            `tmux display-message -p '\#{client_termname}'`.chomp
+          rescue StandardError
+            ''
+          end
+          output.include?('ghostty') || output.include?('kitty')
+        end
+      end
+
       # Check if running inside tmux
       def in_tmux?
         # tmux sets TERM to screen-* or tmux-*
         ENV['TERM']&.include?('screen') || ENV['TERM']&.start_with?('tmux')
       end
 
-      # Print an inline image using iTerm2 protocol
+      # Print an inline image using the appropriate protocol
       # In tmux, uses passthrough sequence and cursor positioning
       def print_inline_image(path, height: 1)
-        data = read_image_data(path)
+        data = read_image_data_for_protocol(path)
         return unless data
 
         encoded = [data].pack('m0')
-        in_tmux? ? print_tmux_image(encoded, height) : print_iterm_image(encoded, height)
+
+        if kitty_graphics_supported?
+          in_tmux? ? print_tmux_kitty_image(encoded, height) : print_kitty_image(encoded, height)
+        else
+          in_tmux? ? print_tmux_iterm_image(encoded, height) : print_iterm_image(encoded, height)
+        end
       end
 
-      def read_image_data(path)
+      def read_image_data_for_protocol(path)
         return nil unless File.exist?(path)
 
-        File.binread(path)
+        data = File.binread(path)
+        return nil unless data
+
+        # Kitty protocol requires PNG format; convert GIF/JPEG if needed
+        if kitty_graphics_supported? && !png_data?(data)
+          convert_to_png(path)
+        else
+          data
+        end
       rescue IOError, SystemCallError
         nil
       end
 
-      def print_tmux_image(encoded, height)
+      def png_data?(data)
+        # PNG files start with magic bytes: 137 80 78 71 13 10 26 10
+        data[0, 8]&.bytes == [137, 80, 78, 71, 13, 10, 26, 10]
+      end
+
+      def convert_to_png(path)
+        # Use sips (macOS) to convert to PNG
+        require 'tempfile'
+        temp = Tempfile.new(['emoji', '.png'])
+        temp.close
+
+        system('sips', '-s', 'format', 'png', path, '--out', temp.path,
+               out: File::NULL, err: File::NULL)
+
+        return nil unless File.exist?(temp.path) && File.size(temp.path).positive?
+
+        File.binread(temp.path)
+      ensure
+        temp&.unlink
+      end
+
+      # iTerm2 protocol methods
+      def print_tmux_iterm_image(encoded, height)
         fmt = "\ePtmux;\e\e]1337;File=inline=1;preserveAspectRatio=0;" \
               "size=%<size>d;height=%<height>d:%<data>s\a\e\\\n "
         printf fmt, size: encoded.length, height: height, data: encoded
@@ -49,6 +112,26 @@ module Slk
         printf "\e]1337;File=inline=1;height=%<height>d:%<data>s\a", height: height, data: encoded
       end
 
+      # Kitty graphics protocol methods (Ghostty, Kitty)
+      # a=T: transmit and display, q=1: suppress OK response, f=100: PNG, r=rows, m=0: no more chunks
+      def print_kitty_image(encoded, height)
+        printf "\e_Ga=T,q=1,f=100,r=%<height>d,m=0;%<data>s\e\\", height: height, data: encoded
+      end
+
+      # Kitty graphics with Unicode placeholders for tmux (images clear/scroll with text)
+      # See: https://sw.kovidgoyal.net/kitty/graphics-protocol/#unicode-placeholders
+      def print_tmux_kitty_image(encoded, _height)
+        @kitty_image_id ||= 30
+        @kitty_image_id = (@kitty_image_id % 255) + 1
+        image_id = @kitty_image_id
+
+        # tmux passthrough: transmit image with Unicode placeholder mode (U=1), 2 cols x 1 row
+        $stdout.print "\ePtmux;\e\e_Ga=T,U=1,q=1,f=100,i=#{image_id},c=2,r=1,m=0;#{encoded}\e\e\\\e\\"
+        # Output placeholder cells (U+10EEEE + row/col diacritics) with foreground color = image_id
+        $stdout.print "\e[38;5;#{image_id}m\u{10EEEE}\u0305\u0305\u{10EEEE}\u0305\u030D\e[39m"
+        $stdout.flush
+      end
+
       # Print inline image with name on same line
       # Handles tmux cursor positioning to keep image and text on same line
       def print_inline_image_with_text(path, text, height: 1) # rubocop:disable Naming/PredicateMethod
@@ -56,11 +139,12 @@ module Slk
 
         print_inline_image(path, height: height)
 
-        if in_tmux?
-          # tmux: image ends with \n + space, cursor on next line
+        if in_tmux? && !kitty_graphics_supported?
+          # iTerm2 in tmux: image ends with \n + space, cursor on next line
           # Move up 1 line, right 3 cols (past image), then print text
           print "\e[1A\e[3C#{text}\n"
         else
+          # Direct output or Unicode placeholders (regular text, just print after)
           puts " #{text}"
         end
 

data/lib/slk/support/platform.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Slk
+  module Support
+    # Cross-platform utilities for OS-specific operations
+    module Platform
+      module_function
+
+      def windows?
+        Gem.win_platform?
+      end
+
+      def macos?
+        RUBY_PLATFORM.include?('darwin')
+      end
+
+      def linux?
+        RUBY_PLATFORM.include?('linux')
+      end
+
+      # Open a URL or file with the system's default handler.
+      # Uses: open (macOS), start (Windows), xdg-open (Linux)
+      def open_url(url)
+        if windows?
+          system('start', '', url)
+        elsif macos?
+          system('open', url)
+        else
+          system('xdg-open', url)
+        end
+      end
+    end
+  end
+end

data/lib/slk/support/xdg_paths.rb

@@ -2,22 +2,40 @@
 
 module Slk
   module Support
-    # XDG-compliant paths for config and cache directories
+    # Cross-platform paths for config and cache directories.
+    # Uses XDG Base Directory spec on Unix, APPDATA/LOCALAPPDATA on Windows.
     class XdgPaths
+      WINDOWS = Gem.win_platform?
+
       def config_dir
-        @config_dir ||= File.join(
-          ENV.fetch('XDG_CONFIG_HOME', File.join(Dir.home, '.config')),
-          'slk'
-        )
+        @config_dir ||= normalize_path(File.join(default_config_base, 'slk'))
       end
 
       def cache_dir
-        @cache_dir ||= File.join(
-          ENV.fetch('XDG_CACHE_HOME', File.join(Dir.home, '.cache')),
-          'slk'
-        )
+        @cache_dir ||= normalize_path(File.join(default_cache_base, 'slk'))
+      end
+
+      private
+
+      def default_config_base
+        return ENV.fetch('XDG_CONFIG_HOME', File.join(Dir.home, '.config')) unless WINDOWS
+
+        ENV.fetch('APPDATA', File.join(Dir.home, 'AppData', 'Roaming'))
       end
 
+      def default_cache_base
+        return ENV.fetch('XDG_CACHE_HOME', File.join(Dir.home, '.cache')) unless WINDOWS
+
+        ENV.fetch('LOCALAPPDATA', File.join(Dir.home, 'AppData', 'Local'))
+      end
+
+      # Normalize path separators to forward slashes for Dir.glob compatibility on Windows
+      def normalize_path(path)
+        WINDOWS ? path.tr('\\', '/') : path
+      end
+
+      public
+
       def config_file(filename)
         File.join(config_dir, filename)
       end

data/lib/slk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Slk
-  VERSION = '0.2.0'
+  VERSION = '0.4.1'
 end

data/lib/slk.rb

@@ -32,6 +32,8 @@ module Slk
     autoload :User, 'slk/models/user'
     autoload :Channel, 'slk/models/channel'
     autoload :Preset, 'slk/models/preset'
+    autoload :SearchResult, 'slk/models/search_result'
+    autoload :SavedItem, 'slk/models/saved_item'
   end
 
   # Application services for configuration, caching, and API communication
@@ -39,6 +41,8 @@ module Slk
     autoload :ApiClient, 'slk/services/api_client'
     autoload :Configuration, 'slk/services/configuration'
     autoload :TokenStore, 'slk/services/token_store'
+    autoload :TokenLoader, 'slk/services/token_loader'
+    autoload :TokenSaver, 'slk/services/token_saver'
     autoload :CacheStore, 'slk/services/cache_store'
     autoload :PresetStore, 'slk/services/preset_store'
     autoload :Encryption, 'slk/services/encryption'
@@ -50,11 +54,14 @@ module Slk
     autoload :UnreadMarker, 'slk/services/unread_marker'
     autoload :TargetResolver, 'slk/services/target_resolver'
     autoload :SetupWizard, 'slk/services/setup_wizard'
+    autoload :UserLookup, 'slk/services/user_lookup'
+    autoload :MessageResolver, 'slk/services/message_resolver'
   end
 
   # Output formatters for messages, durations, and emoji
   module Formatters
     autoload :Output, 'slk/formatters/output'
+    autoload :MarkdownOutput, 'slk/formatters/markdown_output'
     autoload :DurationFormatter, 'slk/formatters/duration_formatter'
     autoload :MentionReplacer, 'slk/formatters/mention_replacer'
     autoload :EmojiReplacer, 'slk/formatters/emoji_replacer'
@@ -64,6 +71,9 @@ module Slk
     autoload :ActivityFormatter, 'slk/formatters/activity_formatter'
     autoload :AttachmentFormatter, 'slk/formatters/attachment_formatter'
     autoload :BlockFormatter, 'slk/formatters/block_formatter'
+    autoload :SearchFormatter, 'slk/formatters/search_formatter'
+    autoload :SavedItemFormatter, 'slk/formatters/saved_item_formatter'
+    autoload :TextProcessor, 'slk/formatters/text_processor'
   end
 
   # CLI commands implementing user-facing functionality
@@ -77,12 +87,14 @@ module Slk
     autoload :Unread, 'slk/commands/unread'
     autoload :Catchup, 'slk/commands/catchup'
     autoload :Activity, 'slk/commands/activity'
+    autoload :Search, 'slk/commands/search'
     autoload :Preset, 'slk/commands/preset'
     autoload :Workspaces, 'slk/commands/workspaces'
     autoload :Cache, 'slk/commands/cache'
     autoload :Emoji, 'slk/commands/emoji'
     autoload :Config, 'slk/commands/config'
     autoload :Help, 'slk/commands/help'
+    autoload :Later, 'slk/commands/later'
   end
 
   # Thin wrappers around Slack API endpoints
@@ -96,6 +108,8 @@ module Slk
     autoload :Threads, 'slk/api/threads'
     autoload :Usergroups, 'slk/api/usergroups'
     autoload :Activity, 'slk/api/activity'
+    autoload :Search, 'slk/api/search'
+    autoload :Saved, 'slk/api/saved'
   end
 
   # Utility classes for paths, parsing, and helpers
@@ -108,5 +122,6 @@ module Slk
     autoload :UserResolver, 'slk/support/user_resolver'
     autoload :TextWrapper, 'slk/support/text_wrapper'
     autoload :InteractivePrompt, 'slk/support/interactive_prompt'
+    autoload :DateParser, 'slk/support/date_parser'
   end
 end