teems 0.1.0

data/lib/teems/commands/channels.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Teems
+  module Commands
+    # List joined teams and their channels
+    class Channels < Base
+      def initialize(args, runner:)
+        @options = {}
+        super
+      end
+
+      def execute
+        result = validate_options
+        return result if result
+
+        auth_result = require_auth
+        return auth_result if auth_result
+
+        list_teams_and_channels
+      end
+
+      protected
+
+      def help_text
+        <<~HELP
+          #{output.bold('teems channels')} - List teams and channels
+
+          #{output.bold('USAGE:')}
+            teems channels [options]
+
+          #{output.bold('OPTIONS:')}
+            -v, --verbose    Show debug output
+            -q, --quiet      Suppress output
+            --json           Output as JSON
+
+          #{output.bold('EXAMPLES:')}
+            teems channels           # List all teams and channels
+            teems channels --json    # Output as JSON
+        HELP
+      end
+
+      private
+
+      def list_teams_and_channels
+        display_teams_list(fetch_teams)
+      rescue ApiError => e
+        teams_fetch_error(e)
+      end
+
+      def display_teams_list(teams)
+        teams.empty? ? puts('No teams found') : render_teams(teams)
+        0
+      end
+
+      def teams_fetch_error(err)
+        error("Failed to fetch teams: #{err.message}")
+        1
+      end
+
+      def fetch_teams
+        response = runner.channels_api.list_teams
+        response['value'] || []
+      end
+
+      def render_teams(teams)
+        if @options[:json]
+          output_json(build_json_output(teams))
+        else
+          display_teams(teams)
+        end
+      end
+
+      def display_teams(teams)
+        api = runner.channels_api
+        teams.each do |team_data|
+          puts output.bold(team_data['displayName'])
+          display_team_channels(api, team_data)
+          puts
+        end
+      end
+
+      def display_team_channels(api, team_data)
+        channels = api.list_channels(team_id: team_data['id'])['value'] || []
+        channels.each { |channel_data| display_channel(channel_data, team_data) }
+      rescue ApiError => e
+        puts "  #{output.red('Error:')} #{e.message}"
+      end
+
+      def display_channel(channel_data, team_data)
+        channel = Models::Channel.from_api(channel_data, team_id: team_data['id'],
+                                                         team_name: team_data['displayName'])
+        puts "  #{channel_prefix(channel)} #{channel.name} (#{channel.id})"
+      end
+
+      def channel_prefix(channel) = channel.private? ? output.yellow('🔒') : '  '
+
+      def build_json_output(teams)
+        api = runner.channels_api
+        teams.map { |team| team_to_hash(api, team) }
+      end
+
+      def team_to_hash(api, team_data)
+        team_id = team_data['id']
+        channels_response = api.list_channels(team_id: team_id)
+        {
+          id: team_id,
+          name: team_data['displayName'],
+          channels: (channels_response['value'] || []).map do |channel|
+            { id: channel['id'], name: channel['displayName'], membership_type: channel['membershipType'] }
+          end
+        }
+      end
+    end
+  end
+end

data/lib/teems/commands/chats.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Teems
+  module Commands
+    # Parsing and filtering logic for chats command
+    module ChatsParsing
+      private
+
+      def render_chats(chats)
+        filtered = apply_filters(parse_all_chats(chats))
+        @options[:json] ? output_json(filtered.map { |chat| chat_to_hash(chat) }) : display_chats(filtered)
+      end
+
+      def parse_all_chats(chats)
+        space_names = build_space_names(chats)
+        chats.filter_map { |chat_data| parse_chat(chat_data, space_names) }
+      end
+
+      def build_space_names(chats)
+        chats.each_with_object({}) do |chat_data, map|
+          tp = chat_data['threadProperties'] || {}
+          map[chat_data['id']] = tp['spaceThreadTopic'] if tp['threadType'] == 'space'
+        end
+      end
+
+      def parse_chat(chat_data, space_names)
+        return nil if chat_data['id'] == '48:notifications'
+
+        chat = Models::Chat.from_api(chat_data)
+        resolve_channel_name(chat, chat_data, space_names)
+      end
+
+      def resolve_channel_name(chat, chat_data, space_names)
+        return chat unless chat.channel?
+
+        team_name = space_names[chat_data.dig('threadProperties', 'spaceId')]
+        team_name ? chat.with(topic: "#{team_name} -> #{chat.topic}") : chat
+      end
+
+      def apply_filters(chats)
+        chats = chats.select(&:unread?) if @options[:unread]
+        chats = chats.select(&:favorite?) if @options[:favorites]
+        chats = chats.select(&:pinned?) if @options[:pinned]
+        chats
+      end
+
+      def chat_to_hash(chat)
+        { id: chat.id, topic: chat.topic, chat_type: chat.chat_type,
+          last_updated: chat.last_updated&.iso8601,
+          unread: chat.unread?, favorite: chat.favorite?, pinned: chat.pinned? }
+      end
+    end
+
+    # Display helpers for chats command
+    module ChatsDisplay
+      CHAT_TYPE_ICONS = {
+        'oneOnOne' => "\u{1F464}", 'group' => "\u{1F465}", 'meeting' => "\u{1F4C5}"
+      }.freeze
+
+      private
+
+      def display_chats(chats)
+        return puts('No chats found') if chats.empty?
+
+        chats.each { |chat| display_single_chat(chat) }
+      end
+
+      def display_single_chat(chat)
+        marker = chat.unread? ? output.bold('* ') : '  '
+        icon = CHAT_TYPE_ICONS.fetch(chat.chat_type, "\u{1F4AC}")
+        puts "#{marker}#{icon} #{output.bold(chat.display_name)}"
+        print_chat_details(chat)
+      end
+
+      def print_chat_details(chat)
+        puts "      ID: #{chat.id}"
+        time_str = chat.last_updated&.strftime('%Y-%m-%d %H:%M')
+        puts "      Last updated: #{time_str}" if time_str
+        puts
+      end
+    end
+
+    # List recent chats
+    class Chats < Base
+      include ChatsParsing
+      include ChatsDisplay
+
+      def initialize(args, runner:)
+        @options = {}
+        super
+      end
+
+      def execute
+        result = validate_options
+        return result if result
+
+        auth_result = require_auth
+        return auth_result if auth_result
+
+        list_chats
+      end
+
+      protected
+
+      CHATS_OPTIONS = {
+        '--unread' => ->(opts, _pending) { opts[:unread] = true },
+        '--favorites' => ->(opts, _pending) { opts[:favorites] = true },
+        '--pinned' => ->(opts, _pending) { opts[:pinned] = true }
+      }.freeze
+
+      def handle_option(arg, pending)
+        handler = CHATS_OPTIONS[arg]
+        return super unless handler
+
+        handler.call(@options, pending)
+      end
+
+      def help_text
+        <<~HELP
+          #{output.bold('teems chats')} - List recent chats
+
+          #{output.bold('USAGE:')}
+            teems chats [options]
+
+          #{output.bold('OPTIONS:')}
+            -n, --limit N    Number of chats to show (default: 20)
+            --unread         Show only unread chats
+            --favorites      Show only favorite chats
+            --pinned         Show only pinned chats
+            -v, --verbose    Show debug output
+            -q, --quiet      Suppress output
+            --json           Output as JSON
+
+          #{output.bold('EXAMPLES:')}
+            teems chats              # List recent chats
+            teems chats --unread     # Show only unread chats
+            teems chats --favorites  # Show only favorites
+            teems chats -n 50        # Show 50 chats
+            teems chats --json       # Output as JSON
+        HELP
+      end
+
+      private
+
+      def list_chats
+        render_chats(fetch_chats)
+        0
+      rescue ApiError => e
+        error("Failed to fetch chats: #{e.message}")
+        1
+      end
+
+      def fetch_chats
+        response = with_token_refresh { runner.chats_api.list(limit: @options[:limit]) }
+        response['conversations'] || response['value'] || []
+      end
+    end
+  end
+end

data/lib/teems/commands/help.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Teems
+  module Commands
+    COMMAND_DESCRIPTIONS = [
+      ['activity', 'Show activity feed (mentions, reactions, calendar)'],
+      ['auth', 'Authenticate with Teams'],
+      ['cal', 'List calendar events and view details'],
+      ['channels', 'List joined teams and channels'],
+      ['chats', 'List recent chats'],
+      ['messages', 'Read messages from a channel or chat'],
+      ['sync', 'Sync chat history locally'],
+      ['who', "Look up a user's profile"],
+      ['org', 'Show org chart for a user'],
+      ['ooo', 'Manage out-of-office status'],
+      ['status', 'View and manage your presence status']
+    ].freeze
+
+    # Displays help information for 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 build_header
+        puts build_commands_section
+        puts build_options_section
+        puts build_examples_section
+        puts "Run #{output.cyan('teems <command> --help')} for command-specific help."
+      end
+
+      def build_header
+        <<~HEADER
+          #{output.bold('teems')} - Microsoft Teams CLI v#{VERSION}
+
+          #{output.bold('USAGE:')}
+            teems <command> [options]
+        HEADER
+      end
+
+      def build_commands_section
+        lines = command_descriptions.map { |name, desc| "    #{output.cyan(name.ljust(12))} #{desc}" }
+        "#{output.bold('COMMANDS:')}\n#{lines.join("\n")}\n\n"
+      end
+
+      def command_descriptions = COMMAND_DESCRIPTIONS
+
+      def build_options_section
+        <<~OPTIONS
+          #{output.bold('GLOBAL OPTIONS:')}
+            -n, --limit N          Number of items to show (default: 20)
+            -v, --verbose          Show debug output
+            -q, --quiet            Suppress output
+            --json                 Output as JSON (where supported)
+            -h, --help             Show help
+        OPTIONS
+      end
+
+      def build_examples_section
+        <<~EXAMPLES
+          #{output.bold('EXAMPLES:')}
+            teems auth login               Authenticate via Safari
+            teems auth status              Show authentication status
+            teems cal                      List today's calendar events
+            teems cal tomorrow             Show tomorrow's events
+            teems cal --week               Show this week's events
+            teems cal show 3               View details for event #3
+            teems cal accept 3             Accept event #3
+            teems cal create "Standup" --start "tomorrow 09:00"
+            teems cal delete 3             Delete event #3
+            teems channels                 List all channels
+            teems chats                    List recent chats
+            teems messages <channel-id>    Read messages from a channel
+            teems who                      Show your profile
+            teems who john                 Search for a user
+            teems org                      Show your org chart
+            teems org john --depth 1       Org chart for "john"
+        EXAMPLES
+      end
+
+      def show_command_help(topic)
+        command_class = CLI::COMMANDS[topic]
+        command_class ? execute_help_for(command_class) : unknown_command_help(topic)
+      end
+
+      def execute_help_for(command_class)
+        command_class.new(['--help'], runner: Runner.new(output: output)).execute
+      end
+
+      def unknown_command_help(topic)
+        error("Unknown command: #{topic}")
+        puts "\nAvailable commands: #{CLI::COMMANDS.keys.join(', ')}"
+      end
+    end
+  end
+end

data/lib/teems/commands/messages.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+module Teems
+  module Commands
+    MESSAGES_HELP = <<~HELP
+      teems messages - Read messages from a channel or chat
+
+      USAGE:
+        teems messages <target> [options]
+
+      ARGUMENTS:
+        target           Chat ID, channel ID, or Teams message URL
+
+      OPTIONS:
+        -t, --team ID    Team ID (required for channel messages)
+        -n, --limit N    Number of messages (default: 20)
+        --download       Download file attachments
+        -o, --output-dir Directory for downloads (default: ~/.local/share/teems/downloads)
+        -v, --verbose    Show debug output
+        -q, --quiet      Suppress output
+        --json           Output as JSON
+
+      EXAMPLES:
+        teems messages 19:abc123@thread.v2         # Read chat messages
+        teems messages 19:abc123@thread.v2 -n 50   # Show 50 messages
+        teems messages "https://teams.microsoft.com/l/message/19:abc@thread.v2/123?context=..."
+    HELP
+
+    # Display formatting for messages command
+    module MessagesDisplay
+      REACTION_EMOJI = {
+        'like' => "\u{1F44D}", 'heart' => "\u{2764}\u{FE0F}",
+        'laugh' => "\u{1F602}", 'surprised' => "\u{1F62E}",
+        'sad' => "\u{1F622}", 'angry' => "\u{1F620}",
+        'yes-tone1' => "\u{1F44D}\u{1F3FB}", 'yes-tone2' => "\u{1F44D}\u{1F3FC}",
+        'support' => "\u{1F91D}", 'heartblue' => "\u{1F499}",
+        'computer' => "\u{1F4BB}", '1f37f_popcorn' => "\u{1F37F}",
+        '1f440_eyes' => "\u{1F440}", 'thumbsdown' => "\u{1F44E}"
+      }.freeze
+
+      private
+
+      def display_message(message)
+        puts format_message_header(message)
+        puts "  #{formatted_content(message)}"
+        display_attachments(message)
+        display_reactions(message)
+        puts
+      end
+
+      def format_message_header(message)
+        importance = message.important? ? output.red('!') : ''
+        time = output.blue("[#{message.created_at&.strftime('%Y-%m-%d %H:%M')}]")
+        hash = output.gray(message.short_hash)
+        "#{time} #{hash} #{importance}#{output.bold(message.sender_name)}:#{edited_tag(message)}"
+      end
+
+      def edited_tag(message) = message.edited? ? " #{output.gray('(edited)')}" : ''
+
+      def display_attachments(message)
+        attachments = message.attachments
+        return unless attachments.any?
+
+        names = attachments.map { |att| Formatters::FormatUtils.attachment_name(att) }
+        puts "  #{output.gray("\u{1F4CE} #{names.join(', ')}")}"
+      end
+
+      def display_reactions(message)
+        reactions = message.reactions
+        return unless reactions.any?
+
+        parts = reactions.map { |reaction| Formatters::FormatUtils.format_single_reaction(reaction, REACTION_EMOJI) }
+        puts "  #{output.gray(parts.join(' '))}"
+      end
+
+      def formatted_content(message)
+        message.content_with_mentions_highlighted { |name| output.bold(name) }
+      end
+
+      def message_to_hash(message)
+        { id: message.id, short_hash: message.short_hash,
+          sender_id: message.sender_id,
+          sender_name: message.sender_name, content: message.content,
+          created_at: message.created_at&.iso8601,
+          importance: message.importance, reactions: message.reactions,
+          attachments: message.attachments, edited: message.edited,
+          mentions: message.mentions }
+      end
+    end
+
+    # Download logic for file attachments in messages
+    module AttachmentDownload
+      private
+
+      def download_attachments(messages)
+        attachments = find_downloadable(messages)
+        return puts('No downloadable attachments found') if attachments.empty?
+
+        execute_downloads(attachments)
+      end
+
+      def execute_downloads(attachments)
+        dir = prepare_output_dir
+        count = attachments.sum { |att| download_one(att, dir) }
+        puts "Downloaded #{count} file#{'s' if count != 1} to #{dir}" if count.positive?
+      end
+
+      def find_downloadable(messages)
+        messages.flat_map { |msg| downloadable_from(msg) }
+      end
+
+      def downloadable_from(msg) = msg.downloadable_attachments
+
+      def download_one(att, dir)
+        name = Formatters::FormatUtils.safe_filename(att['fileName'] || att['name'] || 'file')
+        print "\u{1F4CE} Downloading #{name}..."
+        perform_download(att, dir, name)
+      rescue StandardError => e
+        handle_download_error(e)
+      end
+
+      def handle_download_error(err)
+        warn " failed (#{err.message})"
+        0
+      end
+
+      def perform_download(att, dir, name)
+        url = resolve_download_url(att['sharepointIds'])
+        bytes = file_downloader.download(url, unique_path(dir, name))
+        puts " done (#{Formatters::FormatUtils.format_bytes(bytes)})"
+        1
+      end
+
+      def resolve_download_url(sp_ids)
+        result = with_token_refresh do
+          runner.files_api.drive_item(
+            site_id: sp_ids['siteId'], list_id: sp_ids['listId'],
+            item_id: sp_ids['listItemUniqueId']
+          )
+        end
+        result['@microsoft.graph.downloadUrl'] or raise Error, 'No download URL in response'
+      end
+
+      def file_downloader
+        @file_downloader ||= Services::FileDownloader.new
+      end
+
+      def prepare_output_dir
+        dir = @options[:output_dir] || default_download_dir
+        FileUtils.mkdir_p(dir)
+        dir
+      end
+
+      def default_download_dir
+        File.join(Support::XdgPaths.new.data_dir, 'downloads')
+      end
+
+      def unique_path(dir, name)
+        path = File.join(dir, name)
+        return path unless File.exist?(path)
+
+        ext = File.extname(name)
+        base = File.basename(name, ext)
+        counter = 1
+        counter += 1 while File.exist?(path = File.join(dir, "#{base}-#{counter}#{ext}"))
+        path
+      end
+    end
+
+    # Read messages from a channel or chat
+    class Messages < Base
+      include MessagesDisplay
+      include AttachmentDownload
+
+      def initialize(args, runner:)
+        @options = {}
+        super
+      end
+
+      def execute
+        result = validate_options || require_auth
+        return result if result
+
+        target = resolve_target
+        target ? fetch_messages(target) : 1
+      end
+
+      protected
+
+      MESSAGES_OPTIONS = {
+        '-t' => ->(opts, args) { opts[:team_id] = args.shift },
+        '--team' => ->(opts, args) { opts[:team_id] = args.shift },
+        '--download' => ->(opts, _args) { opts[:download] = true },
+        '-o' => ->(opts, args) { opts[:output_dir] = args.shift },
+        '--output-dir' => ->(opts, args) { opts[:output_dir] = args.shift }
+      }.freeze
+
+      def handle_option(arg, pending)
+        handler = MESSAGES_OPTIONS[arg]
+        return super unless handler
+
+        handler.call(@options, pending)
+      end
+
+      def help_text = MESSAGES_HELP
+
+      private
+
+      def resolve_target
+        target = positional_args.first
+        return missing_target unless target
+
+        parse_teams_url_if_needed(target)
+      end
+
+      def missing_target
+        error('Target required. Specify a channel ID, chat ID, or Teams URL.')
+        puts
+        puts 'Usage: teems messages <channel-id|chat-id|teams-url>'
+        puts 'Use "teems channels" or "teems chats" to find IDs.'
+        nil
+      end
+
+      def parse_teams_url_if_needed(target)
+        return target unless target.start_with?('https://')
+
+        result = Services::TeamsUrlParser.parse(target)
+        result ? apply_parsed_url(result) : (error('Invalid Teams URL format') || nil)
+      end
+
+      def apply_parsed_url(result)
+        conversation_id = result.conversation_id
+        team_id = result.team_id
+        debug("Parsed URL: conversation=#{conversation_id}, team=#{team_id}")
+        @options[:team_id] = team_id if team_id
+        conversation_id
+      end
+
+      def fetch_messages(target)
+        @options[:team_id] ? fetch_channel_messages(target) : fetch_chat_messages(target)
+      end
+
+      def fetch_channel_messages(channel_id)
+        response = with_token_refresh do
+          runner.messages_api.channel_messages(
+            channel_id: channel_id, limit: @options[:limit]
+          )
+        end
+        display_messages(extract_messages_data(response))
+      rescue ApiError => e
+        error("Failed to fetch channel messages: #{e.message}")
+      end
+
+      def fetch_chat_messages(chat_id)
+        response = with_token_refresh do
+          runner.messages_api.chat_messages(chat_id: chat_id, limit: @options[:limit])
+        end
+        display_messages(extract_messages_data(response))
+      rescue ApiError => e
+        error("Failed to fetch chat messages: #{e.message}")
+      end
+
+      def extract_messages_data(response) = response['messages'] || response['posts'] || response['value'] || []
+
+      def display_messages(messages_data)
+        return (puts('No messages found') || true) && 0 if messages_data.empty?
+
+        messages = messages_data.map { |msg_data| Models::Message.from_api(msg_data) }.reject(&:system_message?).reverse
+        render_messages(messages)
+        0
+      end
+
+      def render_messages(messages)
+        return output_json(messages.map { |msg| message_to_hash(msg) }) if @options[:json]
+
+        messages.each { |msg| display_message(msg) }
+        download_attachments(messages) if @options[:download]
+      end
+    end
+  end
+end