slk 0.1.0 → 0.2.0

data/lib/slk/commands/activity.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require_relative '../support/help_formatter'
+
+module Slk
+  module Commands
+    # Displays recent activity feed items (reactions, mentions, threads)
+    # rubocop:disable Metrics/ClassLength
+    class Activity < Base
+      def execute
+        result = validate_options
+        return result if result
+
+        workspace = target_workspaces.first
+        fetch_and_display_activity(workspace)
+      rescue ApiError => e
+        error("Failed to fetch activity: #{e.message}")
+        1
+      end
+
+      private
+
+      def fetch_and_display_activity(workspace)
+        api = runner.activity_api(workspace.name)
+        response = api.feed(limit: @options[:limit], types: activity_types)
+
+        return error_result(response) unless response['ok']
+
+        display_activity(workspace, response['items'] || [])
+        0
+      end
+
+      def error_result(response)
+        error("Failed to fetch activity: #{response['error']}")
+        1
+      end
+
+      def display_activity(workspace, items)
+        if @options[:json]
+          output_json(enricher(workspace).enrich_all(items, workspace))
+        else
+          formatter(workspace).display_all(items, workspace, options: display_options(workspace))
+        end
+      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' then @options[:limit] = args.shift.to_i
+        when '--reactions' then @options[:filter] = :reactions
+        when '--mentions' then @options[:filter] = :mentions
+        when '--threads' then @options[:filter] = :threads
+        when '--show-messages', '-m' then @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.')
+        add_options_section(help)
+        help.render
+      end
+
+      def add_options_section(help)
+        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')
+          add_common_options(s)
+        end
+      end
+
+      def add_common_options(section)
+        section.option('--json', 'Output as JSON')
+        section.option('-w, --workspace', 'Specify workspace')
+        section.option('-v, --verbose', 'Show debug information')
+        section.option('-q, --quiet', 'Suppress output')
+      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 enricher(workspace)
+        Services::ActivityEnricher.new(
+          cache_store: cache_store,
+          conversations_api: runner.conversations_api(workspace.name),
+          on_debug: ->(msg) { debug(msg) }
+        )
+      end
+
+      def formatter(workspace)
+        Formatters::ActivityFormatter.new(
+          output: output,
+          enricher: enricher(workspace),
+          emoji_replacer: runner.emoji_replacer,
+          mention_replacer: runner.mention_replacer,
+          on_debug: ->(msg) { debug(msg) }
+        )
+      end
+
+      def display_options(_workspace)
+        {
+          show_messages: @options[:show_messages],
+          fetch_message: ->(ws, channel_id, message_ts) { fetch_message(ws, channel_id, message_ts) }
+        }
+      end
+
+      def fetch_message(workspace, channel_id, message_ts)
+        response = fetch_message_history(workspace, channel_id, message_ts)
+        return nil unless response['ok'] && response['messages']&.any?
+
+        response['messages'].find { |msg| msg['ts'] == message_ts }
+      rescue ApiError => e
+        debug("Could not fetch message #{message_ts} from #{channel_id}: #{e.message}")
+        nil
+      end
+
+      def fetch_message_history(workspace, channel_id, message_ts)
+        api = runner.conversations_api(workspace.name)
+        oldest_ts = (message_ts.to_f - 1).to_s
+        latest_ts = (message_ts.to_f + 1).to_s
+        api.history(channel: channel_id, limit: 10, oldest: oldest_ts, latest: latest_ts)
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/{slack_cli → slk}/commands/base.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Commands
+    # Base class for all CLI commands with option parsing and output helpers
+    # rubocop:disable Metrics/ClassLength
     class Base
       attr_reader :runner, :options, :positional_args
 
@@ -12,7 +14,7 @@ module SlackCli
       end
 
       def execute
-        raise NotImplementedError, "Subclass must implement #execute"
+        raise NotImplementedError, 'Subclass must implement #execute'
       end
 
       protected
@@ -26,14 +28,15 @@ module SlackCli
       def api_client = runner.api_client
 
       def default_options
-        {
-          workspace: nil,
-          all: false,
-          verbose: false,
-          quiet: false,
-          json: false,
-          width: default_width
-        }
+        base_options.merge(formatting_options)
+      end
+
+      def base_options
+        { workspace: nil, all: false, verbose: false, quiet: false, json: false, width: default_width }
+      end
+
+      def formatting_options
+        { no_emoji: false, no_reactions: false, no_names: false, reaction_names: false, reaction_timestamps: false }
       end
 
       # Default wrap width: 72 for interactive terminals, nil (no wrap) otherwise
@@ -48,39 +51,47 @@ module SlackCli
 
         while args.any?
           arg = args.shift
+          next remaining << arg unless arg.start_with?('-')
 
-          case arg
-          when "-w", "--workspace"
-            @options[:workspace] = args.shift
-          when "--width"
-            value = args.shift
-            @options[:width] = value == '0' ? nil : value.to_i
-          when "--no-wrap"
-            @options[:width] = nil
-          when "--all"
-            @options[:all] = true
-          when "-v", "--verbose"
-            @options[:verbose] = true
-          when "-q", "--quiet"
-            @options[:quiet] = true
-          when "--json"
-            @options[:json] = true
-          when "-h", "--help"
-            @options[:help] = true
-          when /^-/
-            # Let subclass handle unknown options
-            handle_option(arg, args, remaining)
-          else
-            remaining << arg
-          end
+          parse_single_option(arg, args, remaining)
         end
 
         remaining
       end
 
+      private
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      def parse_single_option(arg, args, remaining)
+        case arg
+        when '-w', '--workspace' then @options[:workspace] = args.shift
+        when '--width' then parse_width_option(args)
+        when '--no-wrap' then @options[:width] = nil
+        when '--all' then @options[:all] = true
+        when '-v', '--verbose' then @options[:verbose] = true
+        when '-q', '--quiet' then @options[:quiet] = true
+        when '--json' then @options[:json] = true
+        when '-h', '--help' then @options[:help] = true
+        when '--no-emoji' then @options[:no_emoji] = true
+        when '--no-reactions' then @options[:no_reactions] = true
+        when '--no-names' then @options[:no_names] = true
+        when '--reaction-names' then @options[:reaction_names] = true
+        when '--reaction-timestamps' then @options[:reaction_timestamps] = true
+        else handle_option(arg, args, remaining)
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+      def parse_width_option(args)
+        value = args.shift
+        @options[:width] = value == '0' ? nil : value.to_i
+      end
+
+      protected
+
       # Override in subclass to handle command-specific options
       # Return true if option was handled, false to raise unknown option error
-      def handle_option(arg, args, remaining)
+      def handle_option(arg, _args, _remaining) # rubocop:disable Naming/PredicateMethod
         # By default, unknown options are errors
         # Subclasses can override and return true to accept the option,
         # or call super to get this error behavior
@@ -94,13 +105,13 @@ module SlackCli
         return nil if @unknown_options.nil? || @unknown_options.empty?
 
         error("Unknown option: #{@unknown_options.first}")
-        error("Run with --help for available options.")
+        error('Run with --help for available options.')
         1
       end
 
       # Returns true if there are unknown options
-      def has_unknown_options?
-        @unknown_options && @unknown_options.any?
+      def unknown_options?
+        @unknown_options&.any?
       end
 
       # Get workspaces to operate on based on options
@@ -128,13 +139,13 @@ module SlackCli
       # Returns exit code if should return early, nil otherwise
       def validate_options
         return show_help if show_help?
-        return check_unknown_options if has_unknown_options?
+        return check_unknown_options if unknown_options?
 
         nil
       end
 
       def help_text
-        "No help available for this command."
+        'No help available for this command.'
       end
 
       # Output helpers
@@ -152,13 +163,14 @@ module SlackCli
 
       def error(message)
         output.error(message)
+        1
       end
 
       def debug(message)
         output.debug(message) if @options[:verbose]
       end
 
-      def puts(message = "")
+      def puts(message = '')
         output.puts(message) unless @options[:quiet]
       end
 
@@ -170,6 +182,20 @@ module SlackCli
       def output_json(data)
         output.puts(JSON.pretty_generate(data))
       end
+
+      # Build format options hash for message formatting
+      # Subclasses can override to add command-specific options
+      def format_options
+        {
+          no_emoji: @options[:no_emoji],
+          no_reactions: @options[:no_reactions],
+          no_names: @options[:no_names],
+          reaction_names: @options[:reaction_names],
+          reaction_timestamps: @options[:reaction_timestamps],
+          width: @options[:width]
+        }
+      end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/slk/commands/cache.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative '../support/help_formatter'
+
+module Slk
+  module Commands
+    # Manages user and channel name cache
+    # rubocop:disable Metrics/ClassLength
+    class Cache < Base
+      def execute
+        result = validate_options
+        return result if result
+
+        dispatch_action
+      rescue ApiError => e
+        error("Failed: #{e.message}")
+        1
+      end
+
+      private
+
+      def dispatch_action
+        case positional_args
+        in ['status' | 'info'] | [] then show_status
+        in ['clear', *rest] then clear_cache(rest.first)
+        in ['populate' | 'refresh', *rest] then populate_cache(rest.first)
+        else unknown_action
+        end
+      end
+
+      def unknown_action
+        error("Unknown action: #{positional_args.first}")
+        1
+      end
+
+      protected
+
+      def help_text
+        help = Support::HelpFormatter.new('slk cache <action> [workspace]')
+        help.description('Manage user and channel cache.')
+        add_actions_section(help)
+        add_options_section(help)
+        help.render
+      end
+
+      def add_actions_section(help)
+        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
+      end
+
+      def add_options_section(help)
+        help.section('OPTIONS') do |s|
+          s.option('-w, --workspace', 'Specify workspace')
+          s.option('-q, --quiet', 'Suppress output')
+        end
+      end
+
+      private
+
+      def show_status
+        target_workspaces.each { |workspace| display_workspace_status(workspace) }
+        0
+      end
+
+      def display_workspace_status(workspace)
+        puts output.bold(workspace.name) if target_workspaces.size > 1
+        display_cache_counts(workspace)
+        display_cache_file_status(workspace)
+      end
+
+      def display_cache_counts(workspace)
+        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}"
+      end
+
+      def display_cache_file_status(workspace)
+        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
+
+      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 { |workspace| populate_workspace_cache(workspace) }
+        0
+      end
+
+      def populate_workspace_cache(workspace)
+        puts "Populating user cache for #{workspace.name}..."
+        all_users = fetch_all_users(workspace)
+        count = cache_store.populate_user_cache(workspace.name, all_users)
+        puts
+        success("Cached #{count} users for #{workspace.name}")
+      end
+
+      def fetch_all_users(workspace)
+        api = runner.users_api(workspace.name)
+        all_users = []
+        cursor = nil
+
+        loop do
+          response, cursor = fetch_users_page(api, cursor)
+          all_users.concat(response)
+          break if cursor.nil? || cursor.empty?
+
+          print '.'
+        end
+
+        all_users
+      end
+
+      def fetch_users_page(api, cursor)
+        response = api.list(cursor: cursor)
+        users = (response['members'] || []).map { |m| Models::User.from_api(m) }
+        [users, response.dig('response_metadata', 'next_cursor')]
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end