slk 0.1.0

data/lib/slack_cli/cli.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module SlackCli
+  class CLI
+    COMMANDS = {
+      "status" => Commands::Status,
+      "presence" => Commands::Presence,
+      "dnd" => Commands::Dnd,
+      "messages" => Commands::Messages,
+      "thread" => Commands::Thread,
+      "unread" => Commands::Unread,
+      "catchup" => Commands::Catchup,
+      "activity" => Commands::Activity,
+      "preset" => Commands::Preset,
+      "workspaces" => Commands::Workspaces,
+      "cache" => Commands::Cache,
+      "emoji" => Commands::Emoji,
+      "config" => Commands::Config,
+      "help" => Commands::Help
+    }.freeze
+
+    def initialize(argv, output: nil)
+      @argv = argv.dup
+      @output = output || Formatters::Output.new
+    end
+
+    def run
+      command_name, *args = @argv
+
+      # Handle version flags
+      if command_name.nil? || command_name == "--help" || command_name == "-h"
+        return run_command("help", [])
+      end
+
+      if command_name == "--version" || command_name == "-V" || command_name == "version"
+        @output.puts "slk v#{VERSION}"
+        return 0
+      end
+
+      # Look up command
+      if (command_class = COMMANDS[command_name])
+        run_command(command_name, args)
+      elsif preset_exists?(command_name)
+        # Treat as preset shortcut
+        run_command("preset", [command_name] + args)
+      else
+        @output.error("Unknown command: #{command_name}")
+        @output.puts
+        @output.puts "Run 'slk help' for available commands."
+        1
+      end
+    rescue ConfigError => e
+      @output.error(e.message)
+      log_error(e)
+      1
+    rescue EncryptionError => e
+      @output.error("Encryption error: #{e.message}")
+      log_error(e)
+      1
+    rescue ApiError => e
+      @output.error("API error: #{e.message}")
+      log_error(e)
+      1
+    rescue Interrupt
+      @output.puts
+      @output.puts "Interrupted."
+      130
+    rescue StandardError => e
+      @output.error("Unexpected error: #{e.message}")
+      log_path = log_error(e)
+      @output.puts "Details logged to: #{log_path}" if log_path
+      1
+    end
+
+    private
+
+    def run_command(name, args)
+      command_class = COMMANDS[name]
+      return 1 unless command_class
+
+      verbose = args.include?("-v") || args.include?("--verbose")
+
+      # Create output with verbose flag
+      output = Formatters::Output.new(verbose: verbose)
+      runner = Runner.new(output: output)
+
+      # Set up API call logging if verbose
+      if verbose
+        runner.api_client.on_request = ->(method, count) {
+          output.debug("[API ##{count}] #{method}")
+        }
+      end
+
+      command = command_class.new(args, runner: runner)
+      result = command.execute
+
+      # Show API call count if verbose
+      if verbose && runner.api_client.call_count > 0
+        output.debug("Total API calls: #{runner.api_client.call_count}")
+      end
+
+      result
+    ensure
+      # Clean up HTTP connections
+      runner&.api_client&.close
+    end
+
+    def preset_exists?(name)
+      # PresetStore handles JSON parse errors internally via on_warning callback
+      # ConfigError should propagate as it indicates a real configuration problem
+      Services::PresetStore.new.exists?(name)
+    end
+
+    def log_error(error)
+      Support::ErrorLogger.log(error)
+    end
+  end
+end

data/lib/slack_cli/commands/activity.rb

@@ -0,0 +1,292 @@
+# 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/base.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Commands
+    class Base
+      attr_reader :runner, :options, :positional_args
+
+      def initialize(args, runner:)
+        @runner = runner
+        @options = default_options
+        @positional_args = parse_options(args)
+      end
+
+      def execute
+        raise NotImplementedError, "Subclass must implement #execute"
+      end
+
+      protected
+
+      # Convenience accessors
+      def output = runner.output
+      def config = runner.config
+      def cache_store = runner.cache_store
+      def preset_store = runner.preset_store
+      def token_store = runner.token_store
+      def api_client = runner.api_client
+
+      def default_options
+        {
+          workspace: nil,
+          all: false,
+          verbose: false,
+          quiet: false,
+          json: false,
+          width: default_width
+        }
+      end
+
+      # Default wrap width: 72 for interactive terminals, nil (no wrap) otherwise
+      def default_width
+        $stdout.tty? ? 72 : nil
+      end
+
+      def parse_options(args)
+        remaining = []
+        args = args.dup
+        @unknown_options = []
+
+        while args.any?
+          arg = args.shift
+
+          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
+        end
+
+        remaining
+      end
+
+      # 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)
+        # By default, unknown options are errors
+        # Subclasses can override and return true to accept the option,
+        # or call super to get this error behavior
+        @unknown_options ||= []
+        @unknown_options << arg
+        false
+      end
+
+      # Check for unknown options and return error code if any were passed
+      def check_unknown_options
+        return nil if @unknown_options.nil? || @unknown_options.empty?
+
+        error("Unknown option: #{@unknown_options.first}")
+        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?
+      end
+
+      # Get workspaces to operate on based on options
+      def target_workspaces
+        if @options[:all]
+          runner.all_workspaces
+        elsif @options[:workspace]
+          [runner.workspace(@options[:workspace])]
+        else
+          [runner.workspace]
+        end
+      end
+
+      # Show help if requested
+      def show_help?
+        @options[:help]
+      end
+
+      def show_help
+        output.puts help_text
+        0
+      end
+
+      # Call at start of execute to check for help flag and unknown options
+      # 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?
+
+        nil
+      end
+
+      def help_text
+        "No help available for this command."
+      end
+
+      # Output helpers
+      def success(message)
+        output.success(message) unless @options[:quiet]
+      end
+
+      def info(message)
+        output.info(message) unless @options[:quiet]
+      end
+
+      def warn(message)
+        output.warn(message)
+      end
+
+      def error(message)
+        output.error(message)
+      end
+
+      def debug(message)
+        output.debug(message) if @options[:verbose]
+      end
+
+      def puts(message = "")
+        output.puts(message) unless @options[:quiet]
+      end
+
+      def print(message)
+        output.print(message) unless @options[:quiet]
+      end
+
+      # JSON output helper
+      def output_json(data)
+        output.puts(JSON.pretty_generate(data))
+      end
+    end
+  end
+end

data/lib/slack_cli/commands/cache.rb

@@ -0,0 +1,116 @@
+# 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