slk 0.1.0 → 0.2.0

data/lib/slack_cli/commands/activity.rb

@@ -1,292 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../support/help_formatter'
-
-module SlackCli
-  module Commands
-    class Activity < Base
-      def execute
-        result = validate_options
-        return result if result
-
-        workspace = target_workspaces.first
-        api = runner.activity_api(workspace.name)
-
-        response = api.feed(limit: @options[:limit], types: activity_types)
-
-        unless response['ok']
-          error("Failed to fetch activity: #{response['error']}")
-          return 1
-        end
-
-        items = response['items'] || []
-
-        if @options[:json]
-          output_json(items)
-        else
-          display_activity(items, workspace)
-        end
-
-        0
-      rescue ApiError => e
-        error("Failed to fetch activity: #{e.message}")
-        1
-      end
-
-      protected
-
-      def default_options
-        super.merge(
-          limit: 20,
-          filter: :all,
-          show_messages: false
-        )
-      end
-
-      def handle_option(arg, args, remaining)
-        case arg
-        when '-n', '--limit'
-          @options[:limit] = args.shift.to_i
-        when '--reactions'
-          @options[:filter] = :reactions
-        when '--mentions'
-          @options[:filter] = :mentions
-        when '--threads'
-          @options[:filter] = :threads
-        when '--show-messages', '-m'
-          @options[:show_messages] = true
-        else
-          super
-        end
-      end
-
-      def help_text
-        help = Support::HelpFormatter.new('slk activity [options]')
-        help.description('Show recent activity from the activity feed.')
-
-        help.section('OPTIONS') do |s|
-          s.option('-n, --limit N', 'Number of items (default: 20, max: 50)')
-          s.option('--reactions', 'Show only reaction activity')
-          s.option('--mentions', 'Show only mentions')
-          s.option('--threads', 'Show only thread replies')
-          s.option('-m, --show-messages', 'Show the message content for each activity')
-          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 activity_types
-        case @options[:filter]
-        when :reactions
-          'message_reaction'
-        when :mentions
-          'at_user,at_user_group,at_channel,at_everyone'
-        when :threads
-          'thread_v2'
-        else
-          # All activity types that the Slack web UI uses
-          'thread_v2,message_reaction,bot_dm_bundle,at_user,at_user_group,at_channel,at_everyone'
-        end
-      end
-
-      def display_activity(items, workspace)
-        return puts 'No activity found.' if items.empty?
-
-        items.each do |item|
-          display_activity_item(item, workspace)
-        end
-      end
-
-      def display_activity_item(item, workspace)
-        type = item.dig('item', 'type')
-        timestamp = format_activity_time(item['feed_ts'])
-
-        case type
-        when 'message_reaction'
-          display_reaction_activity(item, workspace, timestamp)
-        when 'at_user', 'at_user_group', 'at_channel', 'at_everyone'
-          display_mention_activity(item, workspace, timestamp)
-        when 'thread_v2'
-          display_thread_v2_activity(item, workspace, timestamp)
-        when 'bot_dm_bundle'
-          display_bot_dm_activity(item, workspace, timestamp)
-        else
-          # Unknown activity type - skip silently
-        end
-      end
-
-      def display_reaction_activity(item, workspace, timestamp)
-        reaction_data = item.dig('item', 'reaction')
-        message_data = item.dig('item', 'message')
-        return unless reaction_data && message_data
-
-        user_id = reaction_data['user']
-        username = resolve_user(workspace, user_id)
-        emoji_name = reaction_data['name']
-        emoji = runner.emoji_replacer.lookup_emoji(emoji_name) || ":#{emoji_name}:"
-        channel_id = message_data['channel']
-        channel = resolve_channel(workspace, channel_id)
-
-        puts "#{output.blue(timestamp)} #{output.bold(username)} reacted #{emoji} in #{channel}"
-
-        if @options[:show_messages]
-          message = fetch_message(workspace, channel_id, message_data['ts'])
-          display_message_preview(message, workspace)
-        end
-      end
-
-      def display_mention_activity(item, workspace, timestamp)
-        message_data = item.dig('item', 'message')
-        return unless message_data
-
-        user_id = message_data['author_user_id'] || message_data['user']
-        username = resolve_user(workspace, user_id)
-        channel_id = message_data['channel']
-        channel = resolve_channel(workspace, channel_id)
-
-        puts "#{output.blue(timestamp)} #{output.bold(username)} mentioned you in #{channel}"
-
-        if @options[:show_messages]
-          message = fetch_message(workspace, channel_id, message_data['ts'])
-          display_message_preview(message, workspace)
-        end
-      end
-
-      def display_thread_v2_activity(item, workspace, timestamp)
-        thread_entry = item.dig('item', 'bundle_info', 'payload', 'thread_entry')
-        return unless thread_entry
-
-        channel_id = thread_entry['channel_id']
-        channel = resolve_channel(workspace, channel_id)
-
-        puts "#{output.blue(timestamp)} Thread activity in #{channel}"
-
-        if @options[:show_messages] && thread_entry['thread_ts']
-          # Fetch the thread parent message
-          message = fetch_message(workspace, channel_id, thread_entry['thread_ts'])
-          display_message_preview(message, workspace)
-        end
-      end
-
-      def display_bot_dm_activity(item, workspace, timestamp)
-        message_data = item.dig('item', 'bundle_info', 'payload', 'message')
-        return unless message_data
-
-        channel_id = message_data['channel']
-        message_ts = message_data['ts']
-        channel = resolve_channel(workspace, channel_id)
-
-        puts "#{output.blue(timestamp)} Bot message in #{channel}"
-
-        # Always try to fetch and show the message content (or when --show-messages is enabled)
-        if @options[:show_messages]
-          message = fetch_message(workspace, channel_id, message_ts)
-          display_message_preview(message, workspace) if message
-        end
-      end
-
-      def resolve_user(workspace, user_id)
-        # Try cache first
-        cached = cache_store.get_user(workspace.name, user_id)
-        return cached if cached
-
-        # Fall back to user ID
-        user_id
-      end
-
-      def resolve_channel(workspace, channel_id)
-        # DMs and Group DMs - don't try to resolve
-        return 'DM' if channel_id.start_with?('D')
-        return 'Group DM' if channel_id.start_with?('G')
-
-        # Try cache first
-        cached = cache_store.get_channel_name(workspace.name, channel_id)
-        return "##{cached}" if cached
-
-        # Try to fetch from API
-        begin
-          api = runner.conversations_api(workspace.name)
-          response = api.info(channel: channel_id)
-          if response['ok'] && response['channel']
-            name = response['channel']['name']
-            cache_store.set_channel(workspace.name, name, channel_id)
-            return "##{name}"
-          end
-        rescue ApiError
-          # Fall back to channel ID if API call fails
-        end
-
-        # Fall back to channel ID
-        channel_id
-      end
-
-      def fetch_message(workspace, channel_id, message_ts)
-        api = runner.conversations_api(workspace.name)
-        # Fetch a window of messages around the target timestamp
-        # Use oldest (exclusive) and latest (inclusive) to create a window
-        oldest_ts = (message_ts.to_f - 1).to_s # 1 second before
-        latest_ts = (message_ts.to_f + 1).to_s # 1 second after
-
-        response = api.history(
-          channel: channel_id,
-          limit: 10,
-          oldest: oldest_ts,
-          latest: latest_ts
-        )
-
-        return nil unless response['ok'] && response['messages']&.any?
-
-        # Find the exact message by timestamp
-        response['messages'].find { |msg| msg['ts'] == message_ts }
-      rescue ApiError
-        nil
-      end
-
-      def display_message_preview(message, workspace)
-        return unless message
-
-        # Get username
-        username = if message['user']
-                     resolve_user(workspace, message['user'])
-                   elsif message['bot_id']
-                     'Bot'
-                   else
-                     'Unknown'
-                   end
-
-        # Get text and replace mentions
-        text = message['text'] || ''
-        text = '[No text]' if text.empty?
-        text = runner.mention_replacer.replace(text, workspace) unless text == '[No text]'
-
-        # Format as indented preview
-        lines = text.lines
-        first_line = lines.first&.strip || text
-        first_line = "#{first_line[0..100]}..." if first_line.length > 100
-
-        puts "  └─ #{username}: #{first_line}"
-
-        # Show additional lines if any
-        if lines.length > 1
-          remaining = lines[1..2].map(&:strip).reject(&:empty?)
-          remaining.each do |line|
-            line = "#{line[0..100]}..." if line.length > 100
-            puts "     #{line}"
-          end
-          puts "     [#{lines.length - 3} more lines...]" if lines.length > 3
-        end
-      end
-
-      def format_activity_time(slack_timestamp)
-        time = Time.at(slack_timestamp.to_f)
-        time.strftime('%b %d %-I:%M %p')  # e.g., "Jan 13 2:45 PM"
-      end
-    end
-  end
-end

data/lib/slack_cli/commands/cache.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../support/help_formatter"
-
-module SlackCli
-  module Commands
-    class Cache < Base
-      def execute
-        result = validate_options
-        return result if result
-
-        case positional_args
-        in ["status" | "info"] | []
-          show_status
-        in ["clear", *rest]
-          clear_cache(rest.first)
-        in ["populate" | "refresh", *rest]
-          populate_cache(rest.first)
-        else
-          error("Unknown action: #{positional_args.first}")
-          1
-        end
-      rescue ApiError => e
-        error("Failed: #{e.message}")
-        1
-      end
-
-      protected
-
-      def help_text
-        help = Support::HelpFormatter.new("slk cache <action> [workspace]")
-        help.description("Manage user and channel cache.")
-
-        help.section("ACTIONS") do |s|
-          s.action("status", "Show cache status")
-          s.action("clear [ws]", "Clear cache (all or specific workspace)")
-          s.action("populate [ws]", "Populate user cache from API")
-        end
-
-        help.section("OPTIONS") do |s|
-          s.option("-w, --workspace", "Specify workspace")
-          s.option("-q, --quiet", "Suppress output")
-        end
-
-        help.render
-      end
-
-      private
-
-      def show_status
-        target_workspaces.each do |workspace|
-          if target_workspaces.size > 1
-            puts output.bold(workspace.name)
-          end
-
-          user_count = cache_store.user_cache_size(workspace.name)
-          channel_count = cache_store.channel_cache_size(workspace.name)
-
-          puts "  Users cached: #{user_count}"
-          puts "  Channels cached: #{channel_count}"
-
-          if cache_store.user_cache_file_exists?(workspace.name)
-            puts "  User cache: #{output.green("present")}"
-          else
-            puts "  User cache: #{output.yellow("not populated")}"
-          end
-        end
-
-        0
-      end
-
-      def clear_cache(workspace_name)
-        if workspace_name
-          cache_store.clear_user_cache(workspace_name)
-          cache_store.clear_channel_cache(workspace_name)
-          success("Cleared cache for #{workspace_name}")
-        else
-          cache_store.clear_user_cache
-          cache_store.clear_channel_cache
-          success("Cleared all caches")
-        end
-
-        0
-      end
-
-      def populate_cache(workspace_name)
-        workspaces = workspace_name ? [runner.workspace(workspace_name)] : target_workspaces
-
-        workspaces.each do |workspace|
-          puts "Populating user cache for #{workspace.name}..."
-
-          api = runner.users_api(workspace.name)
-          all_users = []
-          cursor = nil
-
-          loop do
-            response = api.list(cursor: cursor)
-            members = response["members"] || []
-            all_users.concat(members.map { |m| Models::User.from_api(m) })
-
-            cursor = response.dig("response_metadata", "next_cursor")
-            break if cursor.nil? || cursor.empty?
-
-            print "."
-          end
-
-          count = cache_store.populate_user_cache(workspace.name, all_users)
-          puts
-          success("Cached #{count} users for #{workspace.name}")
-        end
-
-        0
-      end
-    end
-  end
-end