slk 0.1.0

data/lib/slack_cli/commands/dnd.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require_relative "../support/help_formatter"
+
+module SlackCli
+  module Commands
+    class Dnd < Base
+      def execute
+        result = validate_options
+        return result if result
+
+        case positional_args
+        in ["status" | "info"]
+          get_status
+        in ["on" | "snooze", *rest]
+          duration = rest.first ? Models::Duration.parse(rest.first) : Models::Duration.parse("1h")
+          set_snooze(duration)
+        in ["off" | "end"]
+          end_snooze
+        in [duration_str] if duration_str.match?(/^\d+[hms]?$/)
+          duration = Models::Duration.parse(duration_str)
+          set_snooze(duration)
+        in []
+          get_status
+        else
+          error("Unknown action: #{positional_args.first}")
+          error("Valid actions: status, on, off, or a duration (e.g., 1h)")
+          1
+        end
+      rescue ArgumentError => e
+        error("Invalid duration: #{e.message}")
+        1
+      rescue ApiError => e
+        error("Failed: #{e.message}")
+        1
+      end
+
+      protected
+
+      def help_text
+        help = Support::HelpFormatter.new("slk dnd [action] [duration]")
+        help.description("Manage Do Not Disturb (snooze) settings.")
+        help.note("GET shows all workspaces by default. SET applies to primary only.")
+
+        help.section("ACTIONS") do |s|
+          s.action("(none)", "Show current DND status (all workspaces)")
+          s.action("status", "Show current DND status")
+          s.action("on [duration]", "Enable snooze (default: 1h)")
+          s.action("off", "Disable snooze")
+          s.action("<duration>", "Enable snooze for specified duration")
+        end
+
+        help.section("DURATION FORMAT") do |s|
+          s.item("1h", "1 hour")
+          s.item("30m", "30 minutes")
+          s.item("1h30m", "1 hour 30 minutes")
+        end
+
+        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
+
+        help.render
+      end
+
+      private
+
+      def get_status
+        # GET defaults to all workspaces unless -w specified
+        workspaces = @options[:workspace] ? [runner.workspace(@options[:workspace])] : runner.all_workspaces
+
+        workspaces.each do |workspace|
+          api = runner.dnd_api(workspace.name)
+          data = api.info
+
+          if workspaces.size > 1
+            puts output.bold(workspace.name)
+          end
+
+          if data["snooze_enabled"]
+            remaining = api.snooze_remaining
+            if remaining
+              puts "  DND: #{output.yellow("snoozing")} (#{remaining} remaining)"
+            else
+              puts "  DND: #{output.yellow("snoozing")} (expired)"
+            end
+          else
+            puts "  DND: #{output.green("off")}"
+          end
+
+          # Show scheduled DND if present
+          if data["dnd_enabled"]
+            start_time = data["next_dnd_start_ts"]
+            end_time = data["next_dnd_end_ts"]
+            if start_time && end_time
+              start_str = Time.at(start_time).strftime("%H:%M")
+              end_str = Time.at(end_time).strftime("%H:%M")
+              puts "  Schedule: #{start_str} - #{end_str}"
+            end
+          end
+        end
+
+        0
+      end
+
+      def set_snooze(duration)
+        target_workspaces.each do |workspace|
+          api = runner.dnd_api(workspace.name)
+          api.set_snooze(duration)
+
+          success("DND enabled for #{duration} on #{workspace.name}")
+        end
+
+        show_all_workspaces_hint
+
+        0
+      end
+
+      def end_snooze
+        target_workspaces.each do |workspace|
+          api = runner.dnd_api(workspace.name)
+          api.end_snooze
+
+          success("DND disabled 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/slack_cli/commands/emoji.rb

@@ -0,0 +1,412 @@
+# frozen_string_literal: true
+
+require_relative "../support/inline_images"
+require_relative "../support/help_formatter"
+
+module SlackCli
+  module Commands
+    class Emoji < Base
+      include Support::InlineImages
+
+      NETWORK_ERRORS = [
+        SocketError,
+        Errno::ECONNREFUSED,
+        Errno::ETIMEDOUT,
+        Net::OpenTimeout,
+        Net::ReadTimeout,
+        URI::InvalidURIError,
+        OpenSSL::SSL::SSLError
+      ].freeze
+
+      def execute
+        result = validate_options
+        return result if result
+
+        case positional_args
+        in ["status" | "list"] | []
+          show_status
+        in ["sync-standard"]
+          sync_standard
+        in ["download", *rest]
+          download_emoji(rest.first)
+        in ["clear", *rest]
+          clear_emoji(rest.first)
+        in ["search", query, *_]
+          search_emoji(query)
+        in ["search"]
+          error("Usage: slk emoji search <query>")
+          1
+        else
+          error("Unknown action: #{positional_args.first}")
+          1
+        end
+      rescue ApiError => e
+        error("Failed: #{e.message}")
+        1
+      end
+
+      protected
+
+      def default_options
+        super.merge(force: false)
+      end
+
+      def handle_option(arg, args, remaining)
+        case arg
+        when "-f", "--force"
+          @options[:force] = true
+        else
+          super
+        end
+      end
+
+      def help_text
+        help = Support::HelpFormatter.new("slk emoji <action> [workspace]")
+        help.description("Manage emoji cache.")
+
+        help.section("ACTIONS") do |s|
+          s.action("status", "Show emoji cache status")
+          s.action("search <query>", "Search emoji by name (all workspaces by default)")
+          s.action("sync-standard", "Download standard emoji database (gemoji)")
+          s.action("download [ws]", "Download workspace custom emoji")
+          s.action("clear [ws]", "Clear emoji cache")
+        end
+
+        help.section("OPTIONS") do |s|
+          s.option("-w, --workspace", "Limit to specific workspace")
+          s.option("-f, --force", "Skip confirmation for clear")
+          s.option("-q, --quiet", "Suppress output")
+        end
+
+        help.render
+      end
+
+      private
+
+      def show_status
+        paths = Support::XdgPaths.new
+        emoji_dir = config.emoji_dir || paths.cache_dir
+        gemoji_path = File.join(paths.cache_dir, "gemoji.json")
+
+        # Show standard emoji status
+        if File.exist?(gemoji_path)
+          begin
+            gemoji = JSON.parse(File.read(gemoji_path))
+            puts "Standard emoji database: #{gemoji.size} emojis"
+          rescue JSON::ParserError
+            puts "Standard emoji database: #{output.yellow("corrupted")}"
+            puts "  Run 'slk emoji sync-standard' to re-download"
+          end
+        else
+          puts "Standard emoji database: #{output.yellow("not downloaded")}"
+          puts "  Run 'slk emoji sync-standard' to download"
+        end
+
+        puts
+        puts "Workspace emojis: (#{emoji_dir})"
+
+        target_workspaces.each do |workspace|
+          workspace_dir = File.join(emoji_dir, workspace.name)
+
+          if Dir.exist?(workspace_dir)
+            files = Dir.glob(File.join(workspace_dir, "*"))
+            count = files.count
+            size = files.sum { |f| safe_file_size(f) }
+            size_str = format_size(size)
+            puts "  #{workspace.name}: #{count} emojis (#{size_str})"
+          else
+            puts "  #{workspace.name}: #{output.yellow("not downloaded")}"
+          end
+        end
+
+        0
+      end
+
+      def search_emoji(query)
+        paths = Support::XdgPaths.new
+        emoji_dir = config.emoji_dir || paths.cache_dir
+        gemoji_path = File.join(paths.cache_dir, "gemoji.json")
+        pattern = Regexp.new(Regexp.escape(query), Regexp::IGNORECASE)
+
+        results = []
+
+        # Search standard emoji
+        if File.exist?(gemoji_path)
+          begin
+            gemoji = JSON.parse(File.read(gemoji_path))
+            gemoji.each do |name, char|
+              results << { name: name, char: char, source: "standard" } if name.match?(pattern)
+            end
+          rescue JSON::ParserError
+            # Skip standard emoji search if cache is corrupted
+            debug("Standard emoji cache corrupted, skipping")
+          end
+        end
+
+        # Search workspace custom emoji (all workspaces by default, or -w to limit)
+        workspaces = @options[:workspace] ? [runner.workspace(@options[:workspace])] : runner.all_workspaces
+        workspaces.each do |workspace|
+          workspace_dir = File.join(emoji_dir, workspace.name)
+          next unless Dir.exist?(workspace_dir)
+
+          Dir.glob(File.join(workspace_dir, "*")).each do |filepath|
+            name = File.basename(filepath, ".*")
+            results << { name: name, path: filepath, source: workspace.name } if name.match?(pattern)
+          end
+        end
+
+        if results.empty?
+          puts "No emoji matching '#{query}'"
+          return 0
+        end
+
+        # Group by source
+        by_source = results.group_by { |r| r[:source] }
+
+        by_source.each do |source, items|
+          puts output.bold(source == "standard" ? "Standard emoji:" : "#{source}:")
+          items.sort_by { |r| r[:name] }.each do |item|
+            if item[:char]
+              puts "#{item[:char]}  :#{item[:name]}:"
+            elsif item[:path]
+              unless print_inline_image_with_text(item[:path], ":#{item[:name]}:")
+                puts ":#{item[:name]}:"
+              end
+            else
+              puts ":#{item[:name]}:"
+            end
+          end
+          puts
+        end
+
+        puts "Found #{results.size} emoji matching '#{query}'"
+        0
+      end
+
+      def print_progress(current, total, downloaded, skipped)
+        # Only update every 1% or when downloading (to show new count)
+        pct = ((current.to_f / total) * 100).round
+        @last_pct ||= -1
+        return if pct == @last_pct && downloaded == (@last_downloaded || 0)
+
+        @last_pct = pct
+        @last_downloaded = downloaded
+
+        bar_width = 20
+        filled = (pct * bar_width / 100).round
+        bar = "=" * filled + "-" * (bar_width - filled)
+        print "\r  [#{bar}] #{pct}% (#{current}/#{total}) +#{downloaded} new"
+        $stdout.flush
+      end
+
+      def format_size(bytes)
+        if bytes >= 1024 * 1024
+          "#{(bytes / (1024.0 * 1024)).round}M"
+        elsif bytes >= 1024
+          "#{(bytes / 1024.0).round}K"
+        else
+          "#{bytes}B"
+        end
+      end
+
+      # Get file size, returning 0 if file doesn't exist or is inaccessible
+      def safe_file_size(path)
+        File.size(path)
+      rescue Errno::ENOENT, Errno::EACCES
+        0
+      end
+
+      def sync_standard
+        paths = Support::XdgPaths.new
+        cache_dir = paths.cache_dir
+        emoji_json_path = File.join(cache_dir, "gemoji.json")
+
+        puts "Downloading standard emoji database..."
+
+        # Download gemoji JSON from GitHub
+        gemoji_url = "https://raw.githubusercontent.com/github/gemoji/master/db/emoji.json"
+
+        begin
+          uri = URI.parse(gemoji_url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          http.cert_store = OpenSSL::X509::Store.new
+          http.cert_store.set_default_paths
+
+          request = Net::HTTP::Get.new(uri)
+          response = http.request(request)
+
+          unless response.is_a?(Net::HTTPSuccess)
+            error("Failed to download: HTTP #{response.code}")
+            return 1
+          end
+
+          # Parse and transform to shortcode -> emoji mapping
+          emoji_data = JSON.parse(response.body)
+          emoji_map = {}
+
+          emoji_data.each do |emoji|
+            char = emoji["emoji"]
+            next unless char
+
+            # Add all aliases
+            (emoji["aliases"] || []).each do |name|
+              emoji_map[name] = char
+            end
+          end
+
+          # Save to cache
+          FileUtils.mkdir_p(cache_dir)
+          File.write(emoji_json_path, JSON.pretty_generate(emoji_map))
+
+          success("Downloaded #{emoji_map.size} standard emoji mappings")
+          puts "  Location: #{emoji_json_path}"
+
+          0
+        rescue JSON::ParserError => e
+          error("Failed to parse emoji data: #{e.message}")
+          1
+        rescue *NETWORK_ERRORS => e
+          error("Network error: #{e.message}")
+          1
+        rescue SystemCallError => e
+          error("File system error: #{e.message}")
+          1
+        end
+      end
+
+      def download_emoji(workspace_name)
+        workspaces = workspace_name ? [runner.workspace(workspace_name)] : target_workspaces
+        paths = Support::XdgPaths.new
+        emoji_dir = config.emoji_dir || paths.cache_dir
+
+        workspaces.each do |workspace|
+          puts "Fetching emoji list for #{workspace.name}..."
+
+          api = runner.emoji_api(workspace.name)
+          emoji_map = api.custom_emoji
+
+          workspace_dir = File.join(emoji_dir, workspace.name)
+          FileUtils.mkdir_p(workspace_dir)
+
+          downloaded = 0
+          skipped = 0
+          failed = 0
+          total = emoji_map.size
+          processed = 0
+
+          # Filter to only downloadable (non-alias) emoji
+          to_download = emoji_map.reject { |_, url| url.start_with?("alias:") }
+          aliases = total - to_download.size
+
+          to_download.each do |name, url|
+            processed += 1
+            ext = File.extname(URI.parse(url).path)
+            ext = ".png" if ext.empty?
+            filepath = File.join(workspace_dir, "#{name}#{ext}")
+
+            # Skip if already exists
+            if File.exist?(filepath)
+              skipped += 1
+              print_progress(processed, to_download.size, downloaded, skipped)
+              next
+            end
+
+            # Download
+            begin
+              uri = URI.parse(url)
+              http = Net::HTTP.new(uri.host, uri.port)
+              http.use_ssl = true
+              http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+              http.cert_store = OpenSSL::X509::Store.new
+              http.cert_store.set_default_paths
+              http.open_timeout = 10
+              http.read_timeout = 30
+
+              request = Net::HTTP::Get.new(uri)
+              response = http.request(request)
+
+              if response.is_a?(Net::HTTPSuccess)
+                File.binwrite(filepath, response.body)
+                downloaded += 1
+              else
+                failed += 1
+              end
+            rescue *NETWORK_ERRORS, SystemCallError => e
+              debug("Failed to download emoji #{name}: #{e.message}")
+              failed += 1
+            end
+
+            print_progress(processed, to_download.size, downloaded, skipped)
+          end
+
+          puts "\r#{" " * 60}\r" # Clear progress line
+          success("Downloaded #{downloaded} new emoji for #{workspace.name}")
+          puts "  Skipped: #{skipped} (already exist), #{aliases} aliases, #{failed} failed" if skipped > 0 || failed > 0
+        end
+
+        0
+      end
+
+      def clear_emoji(workspace_name)
+        paths = Support::XdgPaths.new
+        emoji_dir = config.emoji_dir || paths.cache_dir
+
+        # Gather info about what will be deleted
+        to_clear = []
+        if workspace_name
+          workspace_dir = File.join(emoji_dir, workspace_name)
+          if Dir.exist?(workspace_dir)
+            to_clear << { name: workspace_name, dir: workspace_dir }
+          else
+            puts "No emoji cache for #{workspace_name}"
+            return 0
+          end
+        else
+          target_workspaces.each do |workspace|
+            workspace_dir = File.join(emoji_dir, workspace.name)
+            to_clear << { name: workspace.name, dir: workspace_dir } if Dir.exist?(workspace_dir)
+          end
+
+          if to_clear.empty?
+            puts "No emoji caches to clear"
+            return 0
+          end
+        end
+
+        # Show what will be deleted
+        puts "Will delete:"
+        total_count = 0
+        total_size = 0
+        to_clear.each do |entry|
+          files = Dir.glob(File.join(entry[:dir], "*"))
+          count = files.count
+          size = files.sum { |f| safe_file_size(f) }
+          total_count += count
+          total_size += size
+          puts "  #{entry[:name]}: #{count} files (#{format_size(size)})"
+        end
+        puts "  Total: #{total_count} files (#{format_size(total_size)})"
+
+        # Confirm unless --force
+        unless @options[:force]
+          print "\nAre you sure? [y/N] "
+          response = $stdin.gets&.chomp&.downcase
+          unless response == "y" || response == "yes"
+            puts "Cancelled"
+            return 0
+          end
+        end
+
+        # Delete
+        to_clear.each do |entry|
+          FileUtils.rm_rf(entry[:dir])
+        end
+
+        success("Cleared #{total_count} emoji files")
+        0
+      end
+    end
+  end
+end

data/lib/slack_cli/commands/help.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Commands
+    class Help < Base
+      def execute
+        topic = positional_args.first
+
+        if topic
+          show_command_help(topic)
+        else
+          show_general_help
+        end
+
+        0
+      end
+
+      private
+
+      def show_general_help
+        puts <<~HELP
+          #{output.bold("slk")} - Slack CLI v#{VERSION}
+
+          #{output.bold("USAGE:")}
+            slk <command> [options]
+
+          #{output.bold("COMMANDS:")}
+            #{output.cyan("status")}       Get or set your status
+            #{output.cyan("presence")}     Get or set your presence (away/active)
+            #{output.cyan("dnd")}          Manage Do Not Disturb
+            #{output.cyan("messages")}     Read channel or DM messages
+            #{output.cyan("unread")}       View and clear unread messages
+            #{output.cyan("preset")}       Manage and apply status presets
+            #{output.cyan("workspaces")}   Manage Slack workspaces
+            #{output.cyan("cache")}        Manage user/channel cache
+            #{output.cyan("emoji")}        Download workspace custom emoji
+            #{output.cyan("config")}       Configuration and setup
+
+          #{output.bold("GLOBAL OPTIONS:")}
+            -w, --workspace NAME   Use specific workspace
+            --all                  Apply to all workspaces
+            -v, --verbose          Show debug output
+            -q, --quiet            Suppress output
+            --json                 Output as JSON (where supported)
+            -h, --help             Show help
+
+          #{output.bold("EXAMPLES:")}
+            slk status                       Show current status
+            slk status "Working" :laptop:    Set status
+            slk status clear                 Clear status
+            slk dnd 1h                       Enable DND for 1 hour
+            slk messages #general            Read channel messages
+            slk preset meeting               Apply preset
+
+          Run #{output.cyan("slk <command> --help")} for command-specific help.
+        HELP
+      end
+
+      def show_command_help(topic)
+        command_class = CLI::COMMANDS[topic]
+
+        if command_class
+          # Create instance just to get help text
+          # Call --help directly since help_text is protected
+          runner_stub = Runner.new(output: output)
+          cmd = command_class.new(["--help"], runner: runner_stub)
+          cmd.execute
+        else
+          error("Unknown command: #{topic}")
+          puts
+          puts "Available commands: #{CLI::COMMANDS.keys.join(", ")}"
+        end
+      end
+    end
+  end
+end