slk 0.1.0

data/lib/slack_cli/commands/workspaces.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative "../support/help_formatter"
+
+module SlackCli
+  module Commands
+    class Workspaces < Base
+      def execute
+        result = validate_options
+        return result if result
+
+        case positional_args
+        in ["list"] | []
+          list_workspaces
+        in ["add"]
+          add_workspace
+        in ["remove", name]
+          remove_workspace(name)
+        in ["primary"]
+          show_primary
+        in ["primary", name]
+          set_primary(name)
+        else
+          error("Unknown action: #{positional_args.first}")
+          1
+        end
+      end
+
+      protected
+
+      def help_text
+        help = Support::HelpFormatter.new("slk workspaces <action> [name]")
+        help.description("Manage Slack workspaces.")
+
+        help.section("ACTIONS") do |s|
+          s.action("list", "List configured workspaces")
+          s.action("add", "Add a new workspace (interactive)")
+          s.action("remove <name>", "Remove a workspace")
+          s.action("primary", "Show primary workspace")
+          s.action("primary <name>", "Set primary workspace")
+        end
+
+        help.section("OPTIONS") do |s|
+          s.option("-q, --quiet", "Suppress output")
+        end
+
+        help.render
+      end
+
+      private
+
+      def list_workspaces
+        names = runner.workspace_names
+        primary = config.primary_workspace
+
+        if names.empty?
+          puts "No workspaces configured."
+          puts "Run 'slack workspaces add' to add one."
+          return 0
+        end
+
+        puts "Workspaces:"
+        names.each do |name|
+          marker = name == primary ? output.green("*") : " "
+          puts "  #{marker} #{name}"
+        end
+
+        0
+      end
+
+      def add_workspace
+        print "Workspace name: "
+        name = $stdin.gets&.chomp
+        return error("Name is required") if name.nil? || name.empty?
+
+        if token_store.exists?(name)
+          return error("Workspace '#{name}' already exists")
+        end
+
+        print "Token (xoxb-... or xoxc-...): "
+        token = $stdin.gets&.chomp
+        return error("Token is required") if token.nil? || token.empty?
+
+        cookie = nil
+        if token.start_with?("xoxc-")
+          print "Cookie (d=...): "
+          cookie = $stdin.gets&.chomp
+        end
+
+        token_store.add(name, token, cookie)
+
+        # Set as primary if first workspace
+        if runner.workspace_names.size == 1
+          config.primary_workspace = name
+          success("Added workspace '#{name}' (set as primary)")
+        else
+          success("Added workspace '#{name}'")
+        end
+
+        0
+      end
+
+      def remove_workspace(name)
+        unless token_store.exists?(name)
+          return error("Workspace '#{name}' not found")
+        end
+
+        token_store.remove(name)
+
+        # Clear primary if removing it
+        if config.primary_workspace == name
+          remaining = runner.workspace_names
+          if remaining.any?
+            config.primary_workspace = remaining.first
+            success("Removed workspace '#{name}'. Primary changed to '#{remaining.first}'")
+          else
+            config.primary_workspace = nil
+            success("Removed workspace '#{name}'")
+          end
+        else
+          success("Removed workspace '#{name}'")
+        end
+
+        0
+      end
+
+      def show_primary
+        primary = config.primary_workspace
+
+        if primary
+          puts "Primary workspace: #{primary}"
+        else
+          puts "No primary workspace set."
+        end
+
+        0
+      end
+
+      def set_primary(name)
+        unless token_store.exists?(name)
+          return error("Workspace '#{name}' not found")
+        end
+
+        config.primary_workspace = name
+        success("Primary workspace set to '#{name}'")
+
+        0
+      end
+    end
+  end
+end

data/lib/slack_cli/formatters/duration_formatter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Formatters
+    class DurationFormatter
+      def format(duration)
+        return "" if duration.nil? || duration.zero?
+
+        duration.to_s
+      end
+
+      def format_remaining(seconds)
+        return "" if seconds.nil? || seconds <= 0
+
+        Models::Duration.new(seconds: seconds).to_s
+      end
+
+      def format_until(timestamp)
+        return "" if timestamp.nil? || timestamp <= 0
+
+        remaining = timestamp - Time.now.to_i
+        return "expired" if remaining <= 0
+
+        format_remaining(remaining)
+      end
+    end
+  end
+end

data/lib/slack_cli/formatters/emoji_replacer.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Formatters
+    class EmojiReplacer
+      EMOJI_REGEX = /:([a-zA-Z0-9_+-]+):/
+      SKIN_TONE_REGEX = /::skin-tone-(\d)/
+
+      # Common emoji mappings (subset - full list would be much larger)
+      EMOJI_MAP = {
+        # Faces
+        "smile" => "\u{1F604}", "grinning" => "\u{1F600}", "joy" => "\u{1F602}",
+        "rofl" => "\u{1F923}", "smiley" => "\u{1F603}", "sweat_smile" => "\u{1F605}",
+        "laughing" => "\u{1F606}", "wink" => "\u{1F609}", "blush" => "\u{1F60A}",
+        "yum" => "\u{1F60B}", "sunglasses" => "\u{1F60E}", "heart_eyes" => "\u{1F60D}",
+        "kissing_heart" => "\u{1F618}", "thinking" => "\u{1F914}", "thinking_face" => "\u{1F914}",
+        "raised_eyebrow" => "\u{1F928}", "neutral_face" => "\u{1F610}", "expressionless" => "\u{1F611}",
+        "unamused" => "\u{1F612}", "rolling_eyes" => "\u{1F644}", "grimacing" => "\u{1F62C}",
+        "relieved" => "\u{1F60C}", "pensive" => "\u{1F614}", "sleepy" => "\u{1F62A}",
+        "sleeping" => "\u{1F634}", "sob" => "\u{1F62D}", "cry" => "\u{1F622}",
+        "scream" => "\u{1F631}", "angry" => "\u{1F620}", "rage" => "\u{1F621}",
+
+        # Gestures
+        "wave" => "\u{1F44B}", "+1" => "\u{1F44D}", "-1" => "\u{1F44E}",
+        "thumbsup" => "\u{1F44D}", "thumbsdown" => "\u{1F44E}",
+        "clap" => "\u{1F44F}", "raised_hands" => "\u{1F64C}", "pray" => "\u{1F64F}",
+        "point_up" => "\u{261D}", "point_down" => "\u{1F447}", "point_left" => "\u{1F448}",
+        "point_right" => "\u{1F449}", "ok_hand" => "\u{1F44C}", "v" => "\u{270C}",
+        "muscle" => "\u{1F4AA}", "fist" => "\u{270A}",
+
+        # Hearts
+        "heart" => "\u{2764}", "hearts" => "\u{2665}", "yellow_heart" => "\u{1F49B}",
+        "green_heart" => "\u{1F49A}", "blue_heart" => "\u{1F499}", "purple_heart" => "\u{1F49C}",
+        "black_heart" => "\u{1F5A4}", "broken_heart" => "\u{1F494}", "sparkling_heart" => "\u{1F496}",
+
+        # Objects
+        "fire" => "\u{1F525}", "star" => "\u{2B50}", "sparkles" => "\u{2728}",
+        "boom" => "\u{1F4A5}", "zap" => "\u{26A1}", "sunny" => "\u{2600}",
+        "cloud" => "\u{2601}", "umbrella" => "\u{2614}", "snowflake" => "\u{2744}",
+        "rocket" => "\u{1F680}", "airplane" => "\u{2708}", "car" => "\u{1F697}",
+        "gift" => "\u{1F381}", "trophy" => "\u{1F3C6}", "medal" => "\u{1F3C5}",
+        "bell" => "\u{1F514}", "key" => "\u{1F511}", "lock" => "\u{1F512}",
+        "bulb" => "\u{1F4A1}", "book" => "\u{1F4D6}", "pencil" => "\u{270F}",
+        "memo" => "\u{1F4DD}", "computer" => "\u{1F4BB}", "phone" => "\u{1F4F1}",
+        "camera" => "\u{1F4F7}", "headphones" => "\u{1F3A7}", "microphone" => "\u{1F3A4}",
+
+        # Food
+        "coffee" => "\u{2615}", "tea" => "\u{1F375}", "beer" => "\u{1F37A}",
+        "wine_glass" => "\u{1F377}", "pizza" => "\u{1F355}", "hamburger" => "\u{1F354}",
+        "cake" => "\u{1F370}", "cookie" => "\u{1F36A}", "apple" => "\u{1F34E}",
+        "banana" => "\u{1F34C}", "taco" => "\u{1F32E}", "burrito" => "\u{1F32F}",
+        "knife_fork_plate" => "\u{1F37D}",
+
+        # Nature
+        "dog" => "\u{1F436}", "cat" => "\u{1F431}", "mouse" => "\u{1F42D}",
+        "rabbit" => "\u{1F430}", "bear" => "\u{1F43B}", "panda_face" => "\u{1F43C}",
+        "chicken" => "\u{1F414}", "penguin" => "\u{1F427}", "bird" => "\u{1F426}",
+        "fish" => "\u{1F41F}", "bug" => "\u{1F41B}", "bee" => "\u{1F41D}",
+        "rose" => "\u{1F339}", "sunflower" => "\u{1F33B}", "tree" => "\u{1F333}",
+        "cactus" => "\u{1F335}", "palm_tree" => "\u{1F334}",
+
+        # Symbols
+        "white_check_mark" => "\u{2705}", "heavy_check_mark" => "\u{2714}",
+        "x" => "\u{274C}", "heavy_multiplication_x" => "\u{2716}",
+        "warning" => "\u{26A0}", "no_entry" => "\u{26D4}", "sos" => "\u{1F198}",
+        "question" => "\u{2753}", "exclamation" => "\u{2757}", "bangbang" => "\u{203C}",
+        "100" => "\u{1F4AF}", "1234" => "\u{1F522}",
+
+        # Status-related
+        "house" => "\u{1F3E0}", "office" => "\u{1F3E2}", "hospital" => "\u{1F3E5}",
+        "calendar" => "\u{1F4C5}", "date" => "\u{1F4C5}", "spiral_calendar" => "\u{1F5D3}",
+        "clock1" => "\u{1F550}", "hourglass" => "\u{231B}", "stopwatch" => "\u{23F1}",
+        "zzz" => "\u{1F4A4}", "speech_balloon" => "\u{1F4AC}", "thought_balloon" => "\u{1F4AD}",
+
+        # Common Slack custom
+        "party-blob" => "\u{1F389}", "blob-wave" => "\u{1F44B}",
+        "tada" => "\u{1F389}", "confetti_ball" => "\u{1F38A}",
+        "balloon" => "\u{1F388}", "party_popper" => "\u{1F389}",
+        "eyes" => "\u{1F440}", "eye" => "\u{1F441}",
+        "ear" => "\u{1F442}", "nose" => "\u{1F443}",
+        "brb" => "\u{1F6B6}", "away" => "\u{1F6B6}",
+        "test_tube" => "\u{1F9EA}"
+      }.freeze
+
+      def initialize(custom_emoji: {}, on_debug: nil)
+        @custom_emoji = custom_emoji
+        @on_debug = on_debug
+        @gemoji_cache = load_gemoji_cache
+      end
+
+      def replace(text, workspace = nil)
+        result = text.dup
+
+        # Remove skin tone modifiers (we don't render them in terminal)
+        result.gsub!(SKIN_TONE_REGEX, "")
+
+        # Replace emoji codes
+        result.gsub!(EMOJI_REGEX) do
+          name = ::Regexp.last_match(1)
+          lookup_emoji(name) || ":#{name}:"
+        end
+
+        result
+      end
+
+      def lookup_emoji(name)
+        # Check custom emoji first
+        return nil if @custom_emoji[name] # Custom emoji are URLs, skip for now
+
+        # Check gemoji cache first (from sync-standard)
+        if @gemoji_cache&.key?(name)
+          return @gemoji_cache[name]
+        end
+
+        # Fall back to built-in map
+        EMOJI_MAP[name]
+      end
+
+      def with_custom_emoji(emoji_hash)
+        self.class.new(custom_emoji: emoji_hash, on_debug: @on_debug)
+      end
+
+      private
+
+      def load_gemoji_cache
+        cache_path = File.join(
+          ENV.fetch("XDG_CACHE_HOME", File.expand_path("~/.cache")),
+          "slack-cli",
+          "gemoji.json"
+        )
+
+        return nil unless File.exist?(cache_path)
+
+        JSON.parse(File.read(cache_path))
+      rescue JSON::ParserError => e
+        @on_debug&.call("Failed to load gemoji cache: #{e.message}")
+        nil
+      rescue Errno::ENOENT
+        nil
+      end
+    end
+  end
+end

data/lib/slack_cli/formatters/mention_replacer.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Formatters
+    class MentionReplacer
+      USER_MENTION_REGEX = /<@([UW][A-Z0-9]+)(?:\|([^>]+))?>/
+      CHANNEL_MENTION_REGEX = /<#([A-Z0-9]+)(?:\|([^>]*))?>/
+      SUBTEAM_MENTION_REGEX = /<!subteam\^([A-Z0-9]+)(?:\|@?([^>]+))?>/
+      LINK_REGEX = /<(https?:\/\/[^|>]+)(?:\|([^>]+))?>/
+      SPECIAL_MENTIONS = {
+        "<!here>" => "@here",
+        "<!channel>" => "@channel",
+        "<!everyone>" => "@everyone"
+      }.freeze
+
+      def initialize(cache_store:, api_client: nil, on_debug: nil)
+        @cache = cache_store
+        @api = api_client
+        @on_debug = on_debug
+      end
+
+      def replace(text, workspace)
+        result = text.dup
+
+        # Replace user mentions
+        result.gsub!(USER_MENTION_REGEX) do
+          user_id = ::Regexp.last_match(1)
+          display_name = ::Regexp.last_match(2)
+
+          if display_name && !display_name.empty?
+            "@#{display_name}"
+          else
+            name = lookup_user_name(workspace, user_id)
+            "@#{name || user_id}"
+          end
+        end
+
+        # Replace channel mentions
+        result.gsub!(CHANNEL_MENTION_REGEX) do
+          channel_id = ::Regexp.last_match(1)
+          channel_name = ::Regexp.last_match(2)
+
+          if channel_name && !channel_name.empty?
+            "##{channel_name}"
+          else
+            name = lookup_channel_name(workspace, channel_id)
+            name ? "##{name}" : "##{channel_id}"
+          end
+        end
+
+        # Replace subteam (user group) mentions
+        result.gsub!(SUBTEAM_MENTION_REGEX) do
+          subteam_id = ::Regexp.last_match(1)
+          handle = ::Regexp.last_match(2)
+
+          if handle && !handle.empty?
+            "@#{handle}"
+          else
+            name = lookup_subteam_handle(workspace, subteam_id)
+            "@#{name || subteam_id}"
+          end
+        end
+
+        # Replace links
+        result.gsub!(LINK_REGEX) do
+          url = ::Regexp.last_match(1)
+          label = ::Regexp.last_match(2)
+          label || url
+        end
+
+        # Replace special mentions
+        SPECIAL_MENTIONS.each do |pattern, replacement|
+          result.gsub!(pattern, replacement)
+        end
+
+        result
+      end
+
+      private
+
+      def lookup_user_name(workspace, user_id)
+        # Try cache first
+        cached = @cache.get_user(workspace.name, user_id)
+        return cached if cached
+
+        # Try API lookup
+        return nil unless @api
+
+        begin
+          users_api = Api::Users.new(@api, workspace)
+          response = users_api.info(user_id)
+          if response["ok"] && response["user"]
+            profile = response["user"]["profile"] || {}
+            name = profile["display_name"]
+            name = profile["real_name"] if name.to_s.empty?
+            name = response["user"]["name"] if name.to_s.empty?
+            # Cache for future lookups
+            @cache.set_user(workspace.name, user_id, name, persist: true) if name && !name.empty?
+            return name unless name.to_s.empty?
+          end
+        rescue ApiError => e
+          @on_debug&.call("User lookup failed for #{user_id}: #{e.message}")
+        end
+
+        nil
+      end
+
+      def lookup_channel_name(workspace, channel_id)
+        # Try cache first
+        cached = @cache.get_channel_name(workspace.name, channel_id)
+        return cached if cached
+
+        # Try API lookup
+        return nil unless @api
+
+        begin
+          conversations_api = Api::Conversations.new(@api, workspace)
+          response = conversations_api.info(channel: channel_id)
+          if response["ok"] && response["channel"]
+            name = response["channel"]["name"]
+            # Cache for future lookups
+            @cache.set_channel(workspace.name, name, channel_id) if name
+            return name
+          end
+        rescue ApiError => e
+          @on_debug&.call("Channel lookup failed for #{channel_id}: #{e.message}")
+        end
+
+        nil
+      end
+
+      def lookup_subteam_handle(workspace, subteam_id)
+        # Try cache first
+        cached = @cache.get_subteam(workspace.name, subteam_id)
+        return cached if cached
+
+        # Try API lookup
+        return nil unless @api
+
+        begin
+          usergroups_api = Api::Usergroups.new(@api, workspace)
+          handle = usergroups_api.get_handle(subteam_id)
+          # Cache for future lookups
+          @cache.set_subteam(workspace.name, subteam_id, handle) if handle
+          return handle
+        rescue ApiError => e
+          @on_debug&.call("Subteam lookup failed for #{subteam_id}: #{e.message}")
+        end
+
+        nil
+      end
+    end
+  end
+end