slk 0.1.0 → 0.2.0

data/lib/{slack_cli → slk}/support/help_formatter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Support
     # Formats help text with auto-aligned columns
     #
@@ -47,32 +47,27 @@ module SlackCli
       end
 
       def render
-        lines = []
-        lines << "USAGE: #{@usage}"
-        lines << ""
-
-        if @description
-          lines << @description
-        end
-
-        @notes.each do |note|
-          lines << note
-        end
-
-        lines << "" if @description || @notes.any?
+        lines = build_header
+        lines.concat(build_sections)
+        lines.pop if lines.last == ''
+        lines.join("\n")
+      end
 
-        @sections.each do |section|
-          lines << "#{section.title}:"
-          lines.concat(section.render)
-          lines << ""
-        end
+      private
 
-        # Remove trailing blank line
-        lines.pop if lines.last == ""
+      def build_header
+        lines = ["USAGE: #{@usage}", '']
+        lines << @description if @description
+        @notes.each { |note| lines << note }
+        lines << '' if @description || @notes.any?
+        lines
+      end
 
-        lines.join("\n")
+      def build_sections
+        @sections.flat_map { |section| ["#{section.title}:", *section.render, ''] }
       end
 
+      # Represents a section within help output (OPTIONS, EXAMPLES, etc.)
       class Section
         attr_reader :title
 
@@ -109,30 +104,27 @@ module SlackCli
         def render
           return [] if @items.empty?
 
-          # Calculate max width of left column
-          max_left = @items
-            .reject { |type, _, _| type == :text }
-            .map { |_, left, _| left.length }
-            .max || 0
-
-          # Add padding (2 spaces between columns)
-          padding = 2
-
-          @items.map do |type, left, right|
-            case type
-            when :text
-              "  #{left}"
-            when :example
-              if right
-                "  #{left.ljust(max_left + padding)}#{right}"
-              else
-                "  #{left}"
-              end
-            else
-              "  #{left.ljust(max_left + padding)}#{right}"
-            end
+          max_left = calculate_max_left_width
+          @items.map { |type, left, right| format_item(type, left, right, max_left) }
+        end
+
+        private
+
+        def calculate_max_left_width
+          @items.reject { |type, _, _| type == :text }.map { |_, left, _| left.length }.max || 0
+        end
+
+        def format_item(type, left, right, max_left)
+          case type
+          when :text then "  #{left}"
+          when :example then format_example(left, right, max_left)
+          else "  #{left.ljust(max_left + 2)}#{right}"
           end
         end
+
+        def format_example(left, right, max_left)
+          right ? "  #{left.ljust(max_left + 2)}#{right}" : "  #{left}"
+        end
       end
     end
   end

data/lib/{slack_cli → slk}/support/inline_images.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Support
     # Shared module for inline image display in iTerm2/WezTerm/Mintty terminals
     # Includes special handling for tmux passthrough sequences
@@ -9,40 +9,49 @@ module SlackCli
       def inline_images_supported?
         # iTerm2, WezTerm, Mintty support inline images
         # LC_TERMINAL persists through tmux/ssh
-        ENV["TERM_PROGRAM"] == "iTerm.app" ||
-          ENV["TERM_PROGRAM"] == "WezTerm" ||
-          ENV["LC_TERMINAL"] == "iTerm2" ||
-          ENV["LC_TERMINAL"] == "WezTerm" ||
-          ENV["TERM"] == "mintty"
+        ['iTerm.app', 'WezTerm'].include?(ENV.fetch('TERM_PROGRAM', nil)) ||
+          ENV['LC_TERMINAL'] == 'iTerm2' ||
+          ENV['LC_TERMINAL'] == 'WezTerm' ||
+          ENV['TERM'] == 'mintty'
       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")
+        ENV['TERM']&.include?('screen') || ENV['TERM']&.start_with?('tmux')
       end
 
       # Print an inline image using iTerm2 protocol
       # In tmux, uses passthrough sequence and cursor positioning
       def print_inline_image(path, height: 1)
-        return unless File.exist?(path)
+        data = read_image_data(path)
+        return unless data
 
-        data = File.binread(path)
-        encoded = [data].pack("m0") # Base64 encode
+        encoded = [data].pack('m0')
+        in_tmux? ? print_tmux_image(encoded, height) : print_iterm_image(encoded, height)
+      end
 
-        if in_tmux?
-          # tmux passthrough: \n + space required for image to render
-          printf "\ePtmux;\e\e]1337;File=inline=1;preserveAspectRatio=0;size=%d;height=%d:%s\a\e\\\n ",
-                 encoded.length, height, encoded
-        else
-          # Standard iTerm2 format
-          printf "\e]1337;File=inline=1;height=%d:%s\a", height, encoded
-        end
+      def read_image_data(path)
+        return nil unless File.exist?(path)
+
+        File.binread(path)
+      rescue IOError, SystemCallError
+        nil
+      end
+
+      def print_tmux_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
+      end
+
+      def print_iterm_image(encoded, height)
+        printf "\e]1337;File=inline=1;height=%<height>d:%<data>s\a", height: height, data: encoded
       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)
+      def print_inline_image_with_text(path, text, height: 1) # rubocop:disable Naming/PredicateMethod
         return false unless inline_images_supported? && File.exist?(path)
 
         print_inline_image(path, height: height)

data/lib/slk/support/interactive_prompt.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Slk
+  module Support
+    # Interactive terminal prompt utilities
+    module InteractivePrompt
+      module_function
+
+      # Read a single character from the terminal
+      def read_single_char
+        if $stdin.tty?
+          $stdin.raw(&:readchar)
+        else
+          $stdin.gets&.chomp
+        end
+      rescue Interrupt
+        'q'
+      end
+
+      # Display a prompt and read a single character
+      def prompt_for_action(prompt)
+        print "\n#{prompt} > "
+        input = read_single_char
+        puts
+        input
+      end
+    end
+  end
+end

data/lib/{slack_cli → slk}/support/slack_url_parser.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Support
+    # Parses Slack message URLs into workspace, channel, and timestamp
     class SlackUrlParser
       # Patterns for Slack URLs
       # Channel IDs: C=channel, G=group DM, D=direct message
@@ -30,41 +31,38 @@ module SlackCli
       end
 
       def parse(input)
-        return nil unless input.to_s.include?("slack.com")
+        return nil unless input.to_s.include?('slack.com')
 
         URL_PATTERNS.each do |pattern|
           match = input.match(pattern)
-          next unless match
-
-          workspace = match[1]
-          channel_id = match[2]
-          msg_ts = match[3] ? format_ts(match[3]) : nil
-          thread_ts = match[4]
-
-          return Result.new(
-            workspace: workspace,
-            channel_id: channel_id,
-            msg_ts: msg_ts,
-            thread_ts: thread_ts
-          )
+          return build_result(match) if match
         end
 
         nil
       end
 
       def slack_url?(input)
-        input.to_s.include?("slack.com/archives")
+        input.to_s.include?('slack.com/archives')
       end
 
       private
 
+      def build_result(match)
+        Result.new(
+          workspace: match[1],
+          channel_id: match[2],
+          msg_ts: match[3] ? format_ts(match[3]) : nil,
+          thread_ts: match[4]
+        )
+      end
+
       # Convert Slack URL timestamp format to API format
       # URL: p1234567890123456 -> API: 1234567890.123456
       def format_ts(url_ts)
         return nil unless url_ts
 
         # Remove 'p' prefix if present
-        ts = url_ts.sub(/^p/, "")
+        ts = url_ts.sub(/^p/, '')
 
         # Insert decimal point
         if ts.length > 6

data/lib/slk/support/text_wrapper.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Slk
+  module Support
+    # Text wrapping utilities with ANSI escape code awareness
+    module TextWrapper
+      module_function
+
+      # Calculate visible length of text (excluding ANSI escape codes)
+      def visible_length(text)
+        text.gsub(/\e\[[0-9;]*m/, '').length
+      end
+
+      # Wrap text to width, handling first line differently and preserving existing newlines
+      def wrap(text, first_line_width, continuation_width)
+        result = []
+        text.each_line do |paragraph|
+          process_paragraph(paragraph.chomp, result, first_line_width, continuation_width)
+        end
+        result.join("\n")
+      end
+
+      def process_paragraph(paragraph, result, first_line_width, continuation_width)
+        if paragraph.empty?
+          result << ''
+        else
+          current_first_width = result.empty? ? first_line_width : continuation_width
+          result << wrap_paragraph(paragraph, current_first_width, continuation_width)
+        end
+      end
+
+      # Wrap a single paragraph (no internal newlines)
+      def wrap_paragraph(text, first_width, rest_width)
+        state = { lines: [], current_line: '', current_width: first_width, rest_width: rest_width }
+        text.split(/(\s+)/).each { |word| process_word(word, state) }
+        state[:lines] << state[:current_line] unless state[:current_line].empty?
+        state[:lines].join("\n")
+      end
+
+      def process_word(word, state)
+        if state[:current_line].empty?
+          state[:current_line] = word
+        elsif visible_length(state[:current_line]) + visible_length(word) <= state[:current_width]
+          state[:current_line] += word
+        else
+          start_new_line(word, state)
+        end
+      end
+
+      def start_new_line(word, state)
+        state[:lines] << state[:current_line]
+        state[:current_line] = word.lstrip
+        state[:current_width] = state[:rest_width]
+      end
+    end
+  end
+end

data/lib/slk/support/user_resolver.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Slk
+  module Support
+    # Shared logic for resolving user and channel names from Slack data.
+    # Include this module in commands that need to look up user/channel names.
+    #
+    # == Required Interface
+    # Including classes must provide these methods:
+    # - runner: Returns the Runner instance for API access
+    # - cache_store: Returns the CacheStore for name lookups
+    # - debug(message): Logs debug messages (can be a no-op)
+    module UserResolver
+      # Resolves a DM channel ID to the user's display name
+      # @param workspace [Models::Workspace] The workspace to look up in
+      # @param channel_id [String] The DM channel ID (starts with D)
+      # @param conversations [Api::Conversations] API client for conversation info
+      # @return [String] User name or channel ID if not found
+      def resolve_dm_user_name(workspace, channel_id, conversations)
+        user_id = get_dm_user_id(channel_id, conversations)
+        return channel_id unless user_id
+
+        lookup_user_name(workspace, user_id) || user_id
+      rescue ApiError => e
+        debug("DM info lookup failed for #{channel_id}: #{e.message}")
+        channel_id
+      end
+
+      private
+
+      def get_dm_user_id(channel_id, conversations)
+        info = conversations.info(channel: channel_id)
+        return nil unless info['ok'] && info['channel']
+
+        info['channel']['user']
+      end
+
+      def lookup_user_name(workspace, user_id)
+        cached = cache_store.get_user(workspace.name, user_id)
+        return cached if cached
+
+        fetch_and_cache_user_name(workspace, user_id)
+      end
+
+      def fetch_and_cache_user_name(workspace, user_id)
+        users_api = runner.users_api(workspace.name)
+        user_info = users_api.info(user_id)
+        return nil unless user_info['ok'] && user_info['user']
+
+        name = extract_name_from_user_info(user_info['user'])
+        return nil unless name
+
+        cache_store.set_user(workspace.name, user_id, name, persist: true)
+        name
+      rescue ApiError => e
+        debug("User lookup failed for #{user_id}: #{e.message}")
+        nil
+      end
+
+      def extract_name_from_user_info(user)
+        profile = user['profile'] || {}
+        name = profile['display_name']
+        name = profile['real_name'] if name.to_s.empty?
+        name = user['name'] if name.to_s.empty?
+        name unless name.to_s.empty?
+      end
+
+      public
+
+      # Resolves a channel ID to a formatted label (@username or #channel)
+      # @param workspace [Models::Workspace] The workspace to look up in
+      # @param channel_id [String] The channel ID
+      # @return [String] Formatted label like "@username" or "#channel"
+      def resolve_conversation_label(workspace, channel_id)
+        return resolve_dm_label(workspace, channel_id) if channel_id.start_with?('D')
+
+        resolve_channel_label(workspace, channel_id)
+      end
+
+      # Extracts the user name from a message hash
+      # @param msg [Hash] The message data from API
+      # @param workspace [Models::Workspace] The workspace context
+      # @return [String] User name, user_id as fallback, or "unknown" if neither found
+      def extract_user_from_message(msg, workspace)
+        name_from_user_profile(msg) ||
+          name_from_username(msg) ||
+          name_from_cache(msg, workspace) ||
+          msg['user'] || msg['bot_id'] || 'unknown'
+      end
+
+      private
+
+      def resolve_dm_label(workspace, channel_id)
+        conversations = runner.conversations_api(workspace.name)
+        user_name = resolve_dm_user_name(workspace, channel_id, conversations)
+        "@#{user_name}"
+      end
+
+      def resolve_channel_label(workspace, channel_id)
+        cached_name = cache_store.get_channel_name(workspace.name, channel_id)
+        return "##{cached_name}" if cached_name
+
+        fetch_channel_label(workspace, channel_id)
+      end
+
+      def fetch_channel_label(workspace, channel_id)
+        conversations = runner.conversations_api(workspace.name)
+        response = conversations.info(channel: channel_id)
+        return "##{channel_id}" unless response['ok'] && response['channel']
+
+        name = response['channel']['name']
+        return "##{channel_id}" unless name
+
+        cache_store.set_channel(workspace.name, name, channel_id)
+        "##{name}"
+      rescue ApiError => e
+        debug("Channel info lookup failed for #{channel_id}: #{e.message}")
+        "##{channel_id}"
+      end
+
+      def name_from_user_profile(msg)
+        return nil unless msg['user_profile']
+
+        name = msg['user_profile']['display_name']
+        name = msg['user_profile']['real_name'] if name.to_s.empty?
+        name unless name.to_s.empty?
+      end
+
+      def name_from_username(msg)
+        msg['username'] unless msg['username'].to_s.empty?
+      end
+
+      def name_from_cache(msg, workspace)
+        user_id = msg['user'] || msg['bot_id']
+        return nil unless user_id
+
+        cache_store.get_user(workspace.name, user_id)
+      end
+    end
+  end
+end

data/lib/{slack_cli → slk}/support/xdg_paths.rb

@@ -1,19 +1,20 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Support
+    # XDG-compliant paths for config and cache directories
     class XdgPaths
       def config_dir
         @config_dir ||= File.join(
-          ENV.fetch("XDG_CONFIG_HOME", File.join(Dir.home, ".config")),
-          "slack-cli"
+          ENV.fetch('XDG_CONFIG_HOME', File.join(Dir.home, '.config')),
+          'slk'
         )
       end
 
       def cache_dir
         @cache_dir ||= File.join(
-          ENV.fetch("XDG_CACHE_HOME", File.join(Dir.home, ".cache")),
-          "slack-cli"
+          ENV.fetch('XDG_CACHE_HOME', File.join(Dir.home, '.cache')),
+          'slk'
         )
       end
 

data/lib/slk/version.rb

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

data/lib/slk.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+require 'fileutils'
+require 'optparse'
+require 'time'
+require 'io/console'
+
+# Slack CLI - A command-line interface for Slack
+module Slk
+  class Error < StandardError; end
+  class ApiError < Error; end
+  class ConfigError < Error; end
+  class EncryptionError < Error; end
+  class TokenStoreError < Error; end
+  class WorkspaceNotFoundError < ConfigError; end
+  class PresetNotFoundError < ConfigError; end
+
+  autoload :VERSION, 'slk/version'
+  autoload :CLI, 'slk/cli'
+  autoload :Runner, 'slk/runner'
+
+  # Data models for Slack entities
+  module Models
+    autoload :Duration, 'slk/models/duration'
+    autoload :Workspace, 'slk/models/workspace'
+    autoload :Status, 'slk/models/status'
+    autoload :Message, 'slk/models/message'
+    autoload :Reaction, 'slk/models/reaction'
+    autoload :User, 'slk/models/user'
+    autoload :Channel, 'slk/models/channel'
+    autoload :Preset, 'slk/models/preset'
+  end
+
+  # Application services for configuration, caching, and API communication
+  module Services
+    autoload :ApiClient, 'slk/services/api_client'
+    autoload :Configuration, 'slk/services/configuration'
+    autoload :TokenStore, 'slk/services/token_store'
+    autoload :CacheStore, 'slk/services/cache_store'
+    autoload :PresetStore, 'slk/services/preset_store'
+    autoload :Encryption, 'slk/services/encryption'
+    autoload :ReactionEnricher, 'slk/services/reaction_enricher'
+    autoload :GemojiSync, 'slk/services/gemoji_sync'
+    autoload :EmojiDownloader, 'slk/services/emoji_downloader'
+    autoload :EmojiSearcher, 'slk/services/emoji_searcher'
+    autoload :ActivityEnricher, 'slk/services/activity_enricher'
+    autoload :UnreadMarker, 'slk/services/unread_marker'
+    autoload :TargetResolver, 'slk/services/target_resolver'
+    autoload :SetupWizard, 'slk/services/setup_wizard'
+  end
+
+  # Output formatters for messages, durations, and emoji
+  module Formatters
+    autoload :Output, 'slk/formatters/output'
+    autoload :DurationFormatter, 'slk/formatters/duration_formatter'
+    autoload :MentionReplacer, 'slk/formatters/mention_replacer'
+    autoload :EmojiReplacer, 'slk/formatters/emoji_replacer'
+    autoload :MessageFormatter, 'slk/formatters/message_formatter'
+    autoload :ReactionFormatter, 'slk/formatters/reaction_formatter'
+    autoload :JsonMessageFormatter, 'slk/formatters/json_message_formatter'
+    autoload :ActivityFormatter, 'slk/formatters/activity_formatter'
+    autoload :AttachmentFormatter, 'slk/formatters/attachment_formatter'
+    autoload :BlockFormatter, 'slk/formatters/block_formatter'
+  end
+
+  # CLI commands implementing user-facing functionality
+  module Commands
+    autoload :Base, 'slk/commands/base'
+    autoload :Status, 'slk/commands/status'
+    autoload :Presence, 'slk/commands/presence'
+    autoload :Dnd, 'slk/commands/dnd'
+    autoload :Messages, 'slk/commands/messages'
+    autoload :Thread, 'slk/commands/thread'
+    autoload :Unread, 'slk/commands/unread'
+    autoload :Catchup, 'slk/commands/catchup'
+    autoload :Activity, 'slk/commands/activity'
+    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'
+  end
+
+  # Thin wrappers around Slack API endpoints
+  module Api
+    autoload :Users, 'slk/api/users'
+    autoload :Conversations, 'slk/api/conversations'
+    autoload :Dnd, 'slk/api/dnd'
+    autoload :Emoji, 'slk/api/emoji'
+    autoload :Client, 'slk/api/client'
+    autoload :Bots, 'slk/api/bots'
+    autoload :Threads, 'slk/api/threads'
+    autoload :Usergroups, 'slk/api/usergroups'
+    autoload :Activity, 'slk/api/activity'
+  end
+
+  # Utility classes for paths, parsing, and helpers
+  module Support
+    autoload :XdgPaths, 'slk/support/xdg_paths'
+    autoload :SlackUrlParser, 'slk/support/slack_url_parser'
+    autoload :InlineImages, 'slk/support/inline_images'
+    autoload :HelpFormatter, 'slk/support/help_formatter'
+    autoload :ErrorLogger, 'slk/support/error_logger'
+    autoload :UserResolver, 'slk/support/user_resolver'
+    autoload :TextWrapper, 'slk/support/text_wrapper'
+    autoload :InteractivePrompt, 'slk/support/interactive_prompt'
+  end
+end