slk 0.1.0

data/lib/slack_cli/commands/messages.rb

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+require_relative "../support/help_formatter"
+
+module SlackCli
+  module Commands
+    class Messages < Base
+      def execute
+        result = validate_options
+        return result if result
+
+        target = positional_args.first
+        unless target
+          error("Usage: slk messages <channel|@user|url>")
+          return 1
+        end
+
+        workspace, channel_id, thread_ts, msg_ts = resolve_target(target)
+
+        # Apply default limits based on target type
+        apply_default_limit(msg_ts)
+
+        messages = fetch_messages(workspace, channel_id, thread_ts, oldest: msg_ts)
+
+        # Enrich with reaction timestamps if requested
+        if @options[:reaction_timestamps]
+          enricher = Services::ReactionEnricher.new(activity_api: runner.activity_api(workspace.name))
+          messages = enricher.enrich_messages(messages, channel_id)
+        end
+
+        if @options[:json]
+          format_options = {
+            no_names: @options[:no_names],
+            reaction_timestamps: @options[:reaction_timestamps]
+          }
+          output_json(messages.map { |m| runner.message_formatter.format_json(m, workspace: workspace, options: format_options) })
+        else
+          display_messages(messages, workspace, channel_id)
+        end
+
+        0
+      rescue ApiError => e
+        error("Failed to fetch messages: #{e.message}")
+        1
+      end
+
+      protected
+
+      def default_options
+        super.merge(
+          limit: 500,
+          limit_set: false,
+          threads: false,
+          no_emoji: false,
+          no_reactions: false,
+          no_names: false,
+          workspace_emoji: true, # Default to showing workspace emoji as images
+          reaction_names: false,
+          reaction_timestamps: false
+        )
+      end
+
+      def handle_option(arg, args, remaining)
+        case arg
+        when "-n", "--limit"
+          @options[:limit] = args.shift.to_i
+          @options[:limit_set] = true
+        when "--threads"
+          @options[:threads] = true
+        when "--no-emoji"
+          @options[:no_emoji] = true
+        when "--no-reactions"
+          @options[:no_reactions] = true
+        when "--no-names"
+          @options[:no_names] = true
+        when "--no-workspace-emoji"
+          @options[:workspace_emoji] = false
+        when "--reaction-names"
+          @options[:reaction_names] = true
+        when "--reaction-timestamps"
+          @options[:reaction_timestamps] = true
+        else
+          super
+        end
+      end
+
+      def help_text
+        help = Support::HelpFormatter.new("slk messages <target> [options]")
+        help.description("Read messages from a channel, DM, or thread.")
+
+        help.section("TARGET") do |s|
+          s.item("#channel", "Channel by name")
+          s.item("channel", "Channel by name (without #)")
+          s.item("@user", "Direct message with user")
+          s.item("C123ABC", "Channel by ID")
+          s.item("<slack_url>", "Slack message URL (returns message + subsequent)")
+        end
+
+        help.section("OPTIONS") do |s|
+          s.option("-n, --limit N", "Number of messages (default: 500, or 50 for message URLs)")
+          s.option("--threads", "Show thread replies inline")
+          s.option("--no-emoji", "Show :emoji: codes instead of unicode")
+          s.option("--no-reactions", "Hide reactions")
+          s.option("--no-names", "Skip user name lookups (faster)")
+          s.option("--no-workspace-emoji", "Disable workspace emoji images")
+          s.option("--reaction-names", "Show reactions with user names")
+          s.option("--reaction-timestamps", "Show when each person reacted")
+          s.option("--width N", "Wrap text at N columns (default: 72 on TTY, no wrap otherwise)")
+          s.option("--no-wrap", "Disable text wrapping")
+          s.option("--json", "Output as JSON")
+          s.option("-w, --workspace", "Specify workspace")
+          s.option("-v, --verbose", "Show debug information")
+          s.option("-q, --quiet", "Suppress output")
+        end
+
+        help.render
+      end
+
+      private
+
+      def resolve_target(target)
+        url_parser = Support::SlackUrlParser.new
+
+        # Check if it's a Slack URL
+        if url_parser.slack_url?(target)
+          result = url_parser.parse(target)
+          if result
+            ws = runner.workspace(result.workspace)
+            # thread_ts means it's a thread, msg_ts means start from that message
+            if result.thread?
+              return [ws, result.channel_id, result.thread_ts, nil]
+            else
+              return [ws, result.channel_id, nil, result.msg_ts]
+            end
+          end
+        end
+
+        workspace = target_workspaces.first
+
+        # Direct channel ID
+        if target.match?(/^[CDG][A-Z0-9]+$/)
+          return [workspace, target, nil, nil]
+        end
+
+        # Channel by name
+        if target.start_with?("#") || !target.start_with?("@")
+          channel_name = target.delete_prefix("#")
+          channel_id = resolve_channel(workspace, channel_name)
+          return [workspace, channel_id, nil, nil]
+        end
+
+        # DM by username
+        if target.start_with?("@")
+          username = target.delete_prefix("@")
+          channel_id = resolve_dm(workspace, username)
+          return [workspace, channel_id, nil, nil]
+        end
+
+        raise ConfigError, "Could not resolve target: #{target}"
+      end
+
+      def resolve_channel(workspace, name)
+        # Check cache first
+        cached = cache_store.get_channel_id(workspace.name, name)
+        return cached if cached
+
+        # Search via API
+        api = runner.conversations_api(workspace.name)
+        response = api.list
+
+        channels = response["channels"] || []
+        channel = channels.find { |c| c["name"] == name }
+
+        if channel
+          cache_store.set_channel(workspace.name, name, channel["id"])
+          return channel["id"]
+        end
+
+        raise ConfigError, "Channel not found: ##{name}"
+      end
+
+      def resolve_dm(workspace, username)
+        # Find user ID
+        user_id = find_user_id(workspace, username)
+        raise ConfigError, "User not found: @#{username}" unless user_id
+
+        # Open DM
+        api = runner.conversations_api(workspace.name)
+        response = api.open(users: user_id)
+        response.dig("channel", "id")
+      end
+
+      def find_user_id(workspace, username)
+        # Check cache
+        # Note: We need reverse lookup, which cache_store doesn't support directly
+        # For now, fetch user list and search
+
+        api = runner.users_api(workspace.name)
+        response = api.list
+
+        users = response["members"] || []
+        user = users.find do |u|
+          u["name"] == username ||
+            u.dig("profile", "display_name") == username ||
+            u.dig("profile", "real_name") == username
+        end
+
+        user&.dig("id")
+      end
+
+      # Apply default limit based on target type (50 for message URLs, 500 otherwise)
+      def apply_default_limit(msg_ts)
+        return if @options[:limit_set]
+
+        @options[:limit] = msg_ts ? 50 : 500
+      end
+
+      def fetch_messages(workspace, channel_id, thread_ts = nil, oldest: nil)
+        api = runner.conversations_api(workspace.name)
+
+        if thread_ts
+          # For threads, paginate to fetch all replies
+          messages = fetch_all_thread_replies(api, channel_id, thread_ts)
+
+          # Apply limit (keep parent + last N-1 replies)
+          if @options[:limit] > 0 && messages.length > @options[:limit]
+            messages = [messages.first] + messages.last(@options[:limit] - 1)
+          end
+        else
+          # For channel history, use oldest parameter if provided
+          # Slack API oldest is exclusive - decrement slightly to include the target message
+          oldest_adjusted = oldest ? adjust_timestamp(oldest, -0.000001) : nil
+          response = api.history(channel: channel_id, limit: @options[:limit], oldest: oldest_adjusted)
+          messages = response["messages"] || []
+        end
+
+        # Convert to model objects
+        messages = messages.map { |m| Models::Message.from_api(m, channel_id: channel_id) }
+
+        # Reverse to show oldest first
+        messages.reverse
+      end
+
+      # Adjust a Slack timestamp by a small amount while preserving precision
+      def adjust_timestamp(ts, delta)
+        require 'bigdecimal'
+        (BigDecimal(ts) + BigDecimal(delta.to_s)).to_s('F')
+      end
+
+      def fetch_all_thread_replies(api, channel_id, thread_ts)
+        all_messages = []
+        cursor = nil
+
+        loop do
+          response = api.replies(channel: channel_id, ts: thread_ts, limit: 200, cursor: cursor)
+          page_messages = response["messages"] || []
+          all_messages.concat(page_messages)
+
+          debug("Fetched #{page_messages.length} messages, total: #{all_messages.length}")
+
+          cursor = response.dig("response_metadata", "next_cursor")
+          break if cursor.nil? || cursor.empty? || !response["has_more"]
+        end
+
+        # Deduplicate and sort by timestamp
+        all_messages
+          .uniq { |m| m["ts"] }
+          .sort_by { |m| m["ts"].to_f }
+      end
+
+      def display_messages(messages, workspace, channel_id)
+        formatter = runner.message_formatter
+        format_options = {
+          no_emoji: @options[:no_emoji],
+          no_reactions: @options[:no_reactions],
+          no_names: @options[:no_names],
+          workspace_emoji: @options[:workspace_emoji],
+          reaction_names: @options[:reaction_names],
+          width: @options[:width]
+        }
+
+        messages.each_with_index do |message, index|
+          formatted = formatter.format(message, workspace: workspace, options: format_options)
+          puts formatted
+          puts if index < messages.length - 1
+
+          # Show thread replies if requested
+          if @options[:threads] && message.has_thread? && !message.is_reply?
+            show_thread_replies(workspace, channel_id, message, format_options)
+          end
+        end
+      end
+
+      def show_thread_replies(workspace, channel_id, parent_message, format_options)
+        api = runner.conversations_api(workspace.name)
+        formatter = runner.message_formatter
+
+        # Fetch all replies with pagination
+        replies = fetch_all_thread_replies(api, channel_id, parent_message.ts)
+
+        # Skip the parent message (first one) and show replies
+        replies[1..].each do |reply_data|
+          reply = Models::Message.from_api(reply_data, channel_id: channel_id)
+          formatted = formatter.format(reply, workspace: workspace, options: format_options)
+
+          # Indent multiline messages so continuation lines align with the first line
+          lines = formatted.lines
+          first_line = "  └ #{lines.first}"
+          continuation_lines = lines[1..].map { |line| "    #{line}" }
+
+          puts first_line
+          continuation_lines.each { |line| puts line }
+        end
+      end
+    end
+  end
+end

data/lib/slack_cli/commands/presence.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "../support/help_formatter"
+
+module SlackCli
+  module Commands
+    class Presence < Base
+      def execute
+        result = validate_options
+        return result if result
+
+        case positional_args
+        in ["away"]
+          set_presence("away")
+        in ["auto" | "active"]
+          set_presence("auto")
+        in []
+          get_presence
+        else
+          error("Unknown presence: #{positional_args.first}")
+          error("Valid options: away, auto, active")
+          1
+        end
+      rescue ApiError => e
+        error("Failed: #{e.message}")
+        1
+      end
+
+      protected
+
+      def help_text
+        help = Support::HelpFormatter.new("slk presence [away|auto|active]")
+        help.description("Get or set your presence status.")
+        help.note("GET shows all workspaces by default. SET applies to primary only.")
+
+        help.section("ACTIONS") do |s|
+          s.action("(none)", "Show current presence (all workspaces)")
+          s.action("away", "Set presence to away")
+          s.action("auto", "Set presence to auto (active)")
+          s.action("active", "Alias for auto")
+        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_presence
+        # GET defaults to all workspaces unless -w specified
+        workspaces = @options[:workspace] ? [runner.workspace(@options[:workspace])] : runner.all_workspaces
+
+        workspaces.each do |workspace|
+          data = runner.users_api(workspace.name).get_presence
+
+          if workspaces.size > 1
+            puts output.bold(workspace.name)
+          end
+
+          presence = data[:presence]
+          manual = data[:manual_away]
+
+          status = case [presence, manual]
+          in ["away", true]
+            output.yellow("away (manual)")
+          in ["away", _]
+            output.yellow("away")
+          in ["active", _]
+            output.green("active")
+          else
+            presence
+          end
+
+          puts "  Presence: #{status}"
+        end
+
+        0
+      end
+
+      def set_presence(presence)
+        target_workspaces.each do |workspace|
+          runner.users_api(workspace.name).set_presence(presence)
+
+          status_text = presence == "away" ? output.yellow("away") : output.green("active")
+          success("Presence set to #{status_text} 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/preset.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require_relative "../support/inline_images"
+require_relative "../support/help_formatter"
+
+module SlackCli
+  module Commands
+    class Preset < Base
+      include Support::InlineImages
+      def execute
+        result = validate_options
+        return result if result
+
+        case positional_args
+        in ["list" | "ls"] | []
+          list_presets
+        in ["add"]
+          add_preset
+        in ["edit", name]
+          edit_preset(name)
+        in ["delete" | "rm", name]
+          delete_preset(name)
+        in [name, *]
+          apply_preset(name)
+        end
+      end
+
+      protected
+
+      def help_text
+        help = Support::HelpFormatter.new("slk preset <action|name> [options]")
+        help.description("Manage and apply status presets.")
+
+        help.section("ACTIONS") do |s|
+          s.action("list", "List all presets")
+          s.action("add", "Add a new preset (interactive)")
+          s.action("edit <name>", "Edit an existing preset")
+          s.action("delete <name>", "Delete a preset")
+          s.action("<name>", "Apply a preset")
+        end
+
+        help.section("EXAMPLES") do |s|
+          s.example("slk preset list")
+          s.example("slk preset meeting")
+          s.example("slk preset add")
+        end
+
+        help.section("OPTIONS") do |s|
+          s.option("-w, --workspace", "Specify workspace")
+          s.option("--all", "Apply to all workspaces")
+          s.option("-q, --quiet", "Suppress output")
+        end
+
+        help.render
+      end
+
+      private
+
+      def list_presets
+        presets = preset_store.all
+
+        if presets.empty?
+          puts "No presets configured."
+          return 0
+        end
+
+        puts "Presets:"
+        presets.each do |preset|
+          puts "  #{output.bold(preset.name)}"
+          display_preset_status(preset) unless preset.text.empty? && preset.emoji.empty?
+          puts "    Duration: #{preset.duration}" unless preset.duration == "0"
+          puts "    Presence: #{preset.presence}" if preset.sets_presence?
+          puts "    DND: #{preset.dnd}" if preset.sets_dnd?
+        end
+
+        0
+      end
+
+      def display_preset_status(preset)
+        emoji_name = preset.emoji.delete_prefix(":").delete_suffix(":")
+        emoji_path = find_workspace_emoji_any(emoji_name)
+
+        if emoji_path && inline_images_supported?
+          text = "    #{preset.text}"
+          print_inline_image_with_text(emoji_path, text)
+        else
+          puts "    #{preset.emoji} #{preset.text}"
+        end
+      end
+
+      def find_workspace_emoji_any(emoji_name)
+        return nil if emoji_name.empty?
+
+        paths = Support::XdgPaths.new
+        emoji_dir = config.emoji_dir || paths.cache_dir
+
+        # Search across all workspaces
+        runner.all_workspaces.each do |workspace|
+          workspace_dir = File.join(emoji_dir, workspace.name)
+          next unless Dir.exist?(workspace_dir)
+
+          path = Dir.glob(File.join(workspace_dir, "#{emoji_name}.*")).first
+          return path if path
+        end
+
+        nil
+      end
+
+      def add_preset
+        print "Preset name: "
+        name = $stdin.gets&.chomp
+        return error("Name is required") if name.nil? || name.empty?
+
+        print "Status text: "
+        text = $stdin.gets&.chomp || ""
+
+        print "Emoji (e.g., :calendar:): "
+        emoji = $stdin.gets&.chomp || ""
+
+        print "Duration (e.g., 1h, 30m, or 0 for none): "
+        duration = $stdin.gets&.chomp || "0"
+
+        print "Presence (away/auto or blank): "
+        presence = $stdin.gets&.chomp || ""
+
+        print "DND (e.g., 1h, off, or blank): "
+        dnd = $stdin.gets&.chomp || ""
+
+        preset = Models::Preset.new(
+          name: name,
+          text: text,
+          emoji: emoji,
+          duration: duration,
+          presence: presence,
+          dnd: dnd
+        )
+
+        preset_store.add(preset)
+        success("Preset '#{name}' created")
+
+        0
+      end
+
+      def edit_preset(name)
+        preset = preset_store.get(name)
+        return error("Preset '#{name}' not found") unless preset
+
+        puts "Editing preset '#{name}' (press Enter to keep current value)"
+
+        print "Status text [#{preset.text}]: "
+        text = $stdin.gets&.chomp
+        text = preset.text if text.empty?
+
+        print "Emoji [#{preset.emoji}]: "
+        emoji = $stdin.gets&.chomp
+        emoji = preset.emoji if emoji.empty?
+
+        print "Duration [#{preset.duration}]: "
+        duration = $stdin.gets&.chomp
+        duration = preset.duration if duration.empty?
+
+        print "Presence [#{preset.presence}]: "
+        presence = $stdin.gets&.chomp
+        presence = preset.presence if presence.empty?
+
+        print "DND [#{preset.dnd}]: "
+        dnd = $stdin.gets&.chomp
+        dnd = preset.dnd if dnd.empty?
+
+        updated = Models::Preset.new(
+          name: name,
+          text: text,
+          emoji: emoji,
+          duration: duration,
+          presence: presence,
+          dnd: dnd
+        )
+
+        preset_store.add(updated)
+        success("Preset '#{name}' updated")
+
+        0
+      end
+
+      def delete_preset(name)
+        unless preset_store.exists?(name)
+          return error("Preset '#{name}' not found")
+        end
+
+        preset_store.remove(name)
+        success("Preset '#{name}' deleted")
+
+        0
+      end
+
+      def apply_preset(name)
+        preset = preset_store.get(name)
+        return error("Preset '#{name}' not found") unless preset
+
+        target_workspaces.each do |workspace|
+          # Set status
+          unless preset.clears_status?
+            duration = preset.duration_value
+            runner.users_api(workspace.name).set_status(
+              text: preset.text,
+              emoji: preset.emoji,
+              duration: duration
+            )
+          else
+            runner.users_api(workspace.name).clear_status
+          end
+
+          # Set presence
+          if preset.sets_presence?
+            runner.users_api(workspace.name).set_presence(preset.presence)
+          end
+
+          # Set DND
+          if preset.sets_dnd?
+            dnd_api = runner.dnd_api(workspace.name)
+            if preset.dnd == "off"
+              dnd_api.end_snooze
+            else
+              duration = Models::Duration.parse(preset.dnd)
+              dnd_api.set_snooze(duration)
+            end
+          end
+
+          success("Applied preset '#{name}' on #{workspace.name}")
+        end
+
+        0
+      rescue ApiError => e
+        error("Failed to apply preset: #{e.message}")
+        1
+      end
+    end
+  end
+end