teems 0.1.0

data/lib/teems/formatters/markdown_formatter.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # Formats chat messages as a Markdown document for local storage.
+    # Groups messages by date with human-readable formatting.
+    class MarkdownFormatter
+      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
+
+      def initialize(chat_name:, chat_type: nil, synced_at: nil)
+        @chat_name = chat_name
+        @chat_type = chat_type
+        @synced_at = synced_at
+      end
+
+      # Format an array of Message objects into a Markdown string.
+      # Messages should be in chronological order (oldest first).
+      def format(messages)
+        lines = [build_header, '']
+        return (lines << '_No messages_').join("\n") if messages.empty?
+
+        format_message_groups(messages, lines)
+        lines.join("\n")
+      end
+
+      private
+
+      def format_message_groups(messages, lines)
+        current_date = nil
+        messages.reject(&:system_message?).each do |msg|
+          current_date = append_date_header(lines, msg, current_date)
+          lines.concat(format_message(msg))
+          lines << ''
+        end
+      end
+
+      def append_date_header(lines, msg, current_date)
+        msg_date = msg.created_at&.strftime('%Y-%m-%d')
+        return current_date if msg_date == current_date
+
+        lines << '' if current_date
+        lines.push("## #{msg_date || 'Unknown Date'}", '')
+        msg_date
+      end
+
+      def build_header
+        parts = ["# #{@chat_name}"]
+        parts << "**Type:** #{@chat_type}" if @chat_type
+        parts << "_Synced: #{@synced_at.strftime('%Y-%m-%d %H:%M')}_" if @synced_at
+        parts.join("\n\n")
+      end
+
+      def format_message(msg)
+        [*(msg.reply? ? ['> _Reply to message_'] : []),
+         format_message_header(msg), '',
+         *message_body_lines(msg)]
+      end
+
+      def message_body_lines(msg)
+        content = msg.content
+        result = content.to_s.empty? ? [] : [content]
+        result.concat(format_message_attachments(msg))
+        result.concat(format_message_reactions(msg))
+      end
+
+      def format_message_header(msg)
+        prefix = msg.important? ? '**[!]** ' : ''
+        edited = msg.edited? ? ' _(edited)_' : ''
+        "### #{msg.created_at&.strftime('%H:%M') || '??:??'} — #{prefix}#{msg.sender_name || 'Unknown'}#{edited}"
+      end
+
+      def format_message_attachments(msg)
+        Array(msg.attachments).map { |att| format_attachment(att) }
+      end
+
+      def format_attachment(att)
+        return "\u{1F4CE} #{att}" unless att.is_a?(Hash)
+
+        format_file_attachment(att)
+      end
+
+      def format_file_attachment(att)
+        name = att['fileName'] || att['name'] || 'file'
+        url = att['siteUrl']
+        url&.start_with?('https://') ? "\u{1F4CE} [#{name}](#{url})" : "\u{1F4CE} #{name}"
+      end
+
+      def format_message_reactions(msg)
+        reactions = msg.reactions
+        return [] unless displayable_reactions?(reactions)
+
+        [format_reactions_line(reactions)]
+      end
+
+      def displayable_reactions?(reactions) = reactions.is_a?(Array) && reactions.any?
+
+      def format_reactions_line(reactions)
+        parts = reactions.map { |reaction| FormatUtils.format_single_reaction(reaction, REACTION_EMOJI) }
+        "#{reactions_label} #{parts.join('  ')}"
+      end
+
+      def reactions_label = 'Reactions:'
+    end
+  end
+end

data/lib/teems/formatters/message_formatter.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # Formats messages for terminal display
+    class MessageFormatter
+      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
+
+      def initialize(output:, cache_store: nil)
+        @output = output
+        @cache_store = cache_store
+      end
+
+      def format(message)
+        content = highlight_mentions(message.content, message.mentions)
+        [format_header(message), "  #{content}", format_attachments(message), format_reactions(message)]
+          .compact.join("\n")
+      end
+
+      private
+
+      def format_header(message)
+        importance = message.important? ? @output.red('!') : ''
+        hash = @output.gray(message.short_hash)
+        "#{format_timestamp(message)} #{hash} #{importance}#{@output.bold(message.sender_name)}:#{edited_tag(message)}"
+      end
+
+      def format_timestamp(message) = @output.blue("[#{message.created_at&.strftime('%Y-%m-%d %H:%M')}]")
+
+      def edited_tag(message) = message.edited? ? " #{@output.gray('(edited)')}" : ''
+
+      def format_attachments(message)
+        attachments = message.attachments
+        return unless attachments.any?
+
+        "  #{@output.gray("\u{1F4CE} #{attachment_names(attachments)}")}"
+      end
+
+      def format_reactions(message)
+        reactions = message.reactions
+        return unless reactions.any?
+
+        "  #{@output.gray(reaction_parts(reactions))}"
+      end
+
+      def highlight_mentions(content, mentions)
+        mentions.inject(content) { |text, name| text.gsub(name, @output.bold(name)) }
+      end
+
+      def attachment_names(attachments)
+        attachments.map { |att| FormatUtils.attachment_name(att) }.join(', ')
+      end
+
+      def reaction_parts(reactions)
+        reactions.map { |reaction| FormatUtils.format_single_reaction(reaction, REACTION_EMOJI) }.join(' ')
+      end
+    end
+  end
+end

data/lib/teems/formatters/output.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # ANSI color wrapping helpers for Output
+    module OutputColors
+      def red(text) = wrap(:red, text)
+      def green(text) = wrap(:green, text)
+      def yellow(text) = wrap(:yellow, text)
+      def blue(text) = wrap(:blue, text)
+      def magenta(text) = wrap(:magenta, text)
+      def cyan(text) = wrap(:cyan, text)
+      def gray(text) = wrap(:gray, text)
+      def bold(text) = wrap(:bold, text)
+
+      def with_verbose(mode = :verbose)
+        self.class.new(io: @io, err: @err, color: @color, mode: mode)
+      end
+
+      def with_quiet(mode = :quiet)
+        self.class.new(io: @io, err: @err, color: @color, mode: mode)
+      end
+    end
+
+    # Terminal output with ANSI color support
+    class Output
+      include OutputColors
+
+      COLORS = {
+        red: "\e[0;31m",
+        green: "\e[0;32m",
+        yellow: "\e[0;33m",
+        blue: "\e[0;34m",
+        magenta: "\e[0;35m",
+        cyan: "\e[0;36m",
+        gray: "\e[0;90m",
+        bold: "\e[1m",
+        reset: "\e[0m"
+      }.freeze
+
+      attr_reader :mode
+
+      def initialize(io: $stdout, err: $stderr, color: nil, mode: :normal)
+        @io = io
+        @err = err
+        @color = [true, false].include?(color) ? color : io.tty?
+        @mode = mode
+      end
+
+      def verbose? = @mode == :verbose
+      def quiet? = @mode == :quiet
+      def tty? = @io.tty?
+
+      def puts(message = '')
+        write_unless_quiet { @io.puts(message) }
+      end
+
+      def print(message)
+        write_unless_quiet { @io.print(message) }
+      end
+
+      def flush
+        @io.flush
+      end
+
+      def error(message)
+        @err.puts(colorize("#{red('Error:')} #{message}"))
+      end
+
+      def warn(message)
+        write_unless_quiet { @err.puts(colorize("#{yellow('Warning:')} #{message}")) }
+      end
+
+      def success(message)
+        puts(colorize("#{green('✓')} #{message}"))
+      end
+
+      def info(message)
+        puts(colorize(message))
+      end
+
+      def debug(message)
+        return unless verbose?
+
+        @err.puts(colorize("#{gray('[debug]')} #{message}"))
+      end
+
+      private
+
+      def write_unless_quiet
+        yield unless quiet?
+      end
+
+      def wrap(color, text)
+        return text.to_s unless @color
+
+        "#{COLORS[color]}#{text}#{COLORS[:reset]}"
+      end
+
+      def colorize(text)
+        text
+      end
+    end
+  end
+end

data/lib/teems/models/account.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Teems
+  module Models
+    # Represents a Teams account with authentication tokens
+    Account = Data.define(:name, :auth_token, :skype_token, :chatsvc_token, :presence_token) do
+      def initialize(name:, auth_token:, skype_token:, chatsvc_token: nil, presence_token: nil)
+        validate_tokens!(auth_token, skype_token)
+        super(
+          name: name.to_s.freeze,
+          auth_token: auth_token.to_s.freeze,
+          skype_token: skype_token.to_s.freeze,
+          chatsvc_token: chatsvc_token&.to_s&.freeze,
+          presence_token: presence_token&.to_s&.freeze
+        )
+      end
+
+      # Authorization header for Teams API endpoints
+      def teams_auth_header
+        "Bearer #{auth_token}"
+      end
+
+      # Authorization header for Skype/chat API endpoints
+      def skype_auth_header
+        "skypetoken=#{skype_token}"
+      end
+
+      # Authorization header for chatsvcagg endpoints
+      def chatsvc_auth_header
+        return nil unless chatsvc_token
+
+        "Bearer #{chatsvc_token}"
+      end
+
+      # Headers for Teams API requests
+      def teams_headers
+        {
+          'Authorization' => teams_auth_header,
+          'Content-Type' => 'application/json'
+        }
+      end
+
+      # Headers for Skype API requests
+      def skype_headers
+        {
+          'Authentication' => skype_auth_header,
+          'Content-Type' => 'application/json'
+        }
+      end
+
+      private
+
+      def validate_tokens!(auth_token, skype_token)
+        raise ArgumentError, 'auth_token is required' if auth_token.to_s.empty?
+        raise ArgumentError, 'skype_token is required' if skype_token.to_s.empty?
+      end
+    end
+  end
+end

data/lib/teems/models/channel.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Teems
+  module Models
+    # Represents a Teams channel within a team
+    Channel = Data.define(:id, :name, :team_id, :team_name, :description, :membership_type) do
+      def self.from_api(data, team_id: nil, team_name: nil)
+        new(
+          id: data['id'],
+          name: data['displayName'],
+          team_id: team_id,
+          team_name: team_name,
+          description: data['description'],
+          membership_type: data['membershipType']
+        )
+      end
+
+      def display_name
+        team_name ? "#{team_name} / #{name}" : name
+      end
+
+      def private?
+        membership_type == 'private'
+      end
+
+      def to_s
+        "##{name}"
+      end
+    end
+  end
+end

data/lib/teems/models/chat.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Teems
+  module Models
+    CHAT_TYPE_LABELS = {
+      'oneOnOne' => '1:1 Chat', 'group' => 'Group Chat', 'meeting' => 'Meeting Chat',
+      'channel' => 'Channel', 'space' => 'Space'
+    }.freeze
+
+    # Represents a chat (1:1, group, or meeting chat)
+    Chat = Data.define(:id, :topic, :chat_type, :created_at, :last_updated, :unread, :favorite, :pinned) do
+      def self.from_api(data)
+        # Handle both Graph API format and ng.msg format
+        if data['threadProperties']
+          from_ngmsg(data)
+        else
+          from_graph(data)
+        end
+      end
+
+      def self.from_graph(data)
+        new(
+          id: data['id'],
+          topic: data['topic'],
+          chat_type: data['chatType'],
+          created_at: parse_time(data['createdDateTime']),
+          last_updated: parse_time(data['lastUpdatedDateTime']),
+          unread: false, favorite: false, pinned: false
+        )
+      end
+
+      def self.from_ngmsg(data)
+        thread_props = data['threadProperties'] || {}
+        props = data['properties'] || {}
+        new(
+          id: data['id'],
+          topic: thread_props['topic'] || thread_props['spaceThreadTopic'],
+          chat_type: normalize_chat_type(thread_props['threadType']),
+          created_at: parse_time(thread_props['createdat']),
+          last_updated: parse_time(props['lastimreceivedtime']),
+          **ngmsg_status(props, data['lastMessage'])
+        )
+      end
+
+      def self.ngmsg_status(props, last_message)
+        horizon = props['consumptionhorizon']
+        last_msg_id = last_message&.dig('id')
+        {
+          unread: horizon && last_msg_id ? horizon.split(';').first.to_i < last_msg_id.to_i : false,
+          favorite: props['favorite'] == 'true',
+          pinned: props['ispinned'] == 'true'
+        }
+      end
+
+      # Normalize ng.msg threadType to a consistent chat type.
+      # ng.msg uses: 'chat' (group), 'meeting', 'topic' (channel), 'space'
+      # Normalized to: 'group', 'meeting', 'channel', 'space'
+      def self.normalize_chat_type(type)
+        case type&.downcase
+        when 'chat' then 'group'
+        when 'meeting' then 'meeting'
+        when 'topic' then 'channel'
+        when 'space' then 'space'
+        else type
+        end
+      end
+
+      def self.parse_time(time_str)
+        return nil unless time_str
+
+        Time.parse(time_str)
+      rescue ArgumentError
+        nil
+      end
+
+      def display_name
+        topic.to_s.empty? ? chat_type_label : topic
+      end
+
+      def chat_type_label = CHAT_TYPE_LABELS.fetch(chat_type, chat_type)
+
+      def unread? = unread
+      def favorite? = favorite
+      def pinned? = pinned
+
+      def one_on_one?
+        chat_type == 'oneOnOne'
+      end
+
+      def group?
+        chat_type == 'group'
+      end
+
+      def meeting?
+        chat_type == 'meeting'
+      end
+
+      def channel?
+        chat_type == 'channel'
+      end
+
+      def space?
+        chat_type == 'space'
+      end
+
+      def to_s
+        display_name
+      end
+    end
+  end
+end

data/lib/teems/models/duration.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Teems
+  module Models
+    DURATION_PATTERN = /\A(?:(\d+)h)?(?:(\d+)m)?\z/
+
+    # Immutable duration value object for human-friendly time input
+    Duration = Data.define(:seconds) do
+      def self.parse(input)
+        label = input.inspect
+        match = DURATION_PATTERN.match(input.to_s.strip)
+        raise ArgumentError, "Invalid duration: #{label}" unless match
+
+        total = (match[1].to_i * 3600) + (match[2].to_i * 60)
+        raise ArgumentError, "Duration must be greater than zero: #{label}" if total.zero?
+
+        new(seconds: total)
+      end
+
+      def to_iso8601_duration
+        parts = []
+        parts << "#{hours}H" if hours.positive?
+        parts << "#{minutes}M" if minutes.positive?
+        "PT#{parts.join}"
+      end
+
+      def to_expiration
+        (Time.now.utc + seconds).strftime('%Y-%m-%dT%H:%M:%S.0000000Z')
+      end
+
+      def to_s
+        parts = []
+        parts << "#{hours}h" if hours.positive?
+        parts << "#{minutes}m" if minutes.positive?
+        parts.join(' ')
+      end
+
+      def empty? = seconds.zero?
+
+      private
+
+      def hours = seconds / 3600
+      def minutes = (seconds % 3600) / 60
+    end
+  end
+end

data/lib/teems/models/event.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Teems
+  module Models
+    PENDING_RESPONSES = [nil, 'none'].freeze
+
+    # Represents a calendar event from Microsoft Graph API
+    Event = Data.define(
+      :id,
+      :subject,
+      :start_time,
+      :end_time,
+      :location,
+      :is_all_day,
+      :organizer,
+      :attendees,
+      :body_preview,
+      :online_meeting_url,
+      :show_as,
+      :importance,
+      :is_cancelled,
+      :response_status,
+      :sensitivity,
+      :event_type
+    ) do
+      extend Parsing
+
+      def self.from_api(data)
+        new(**event_attrs(data))
+      end
+
+      def self.event_attrs(data)
+        core_attrs(data).merge(detail_attrs(data))
+      end
+
+      def self.core_attrs(data)
+        {
+          id: data['id'],
+          subject: data['subject'] || '(No subject)',
+          start_time: parse_time(data.dig('start', 'dateTime')),
+          end_time: parse_time(data.dig('end', 'dateTime')),
+          location: data.dig('location', 'displayName'),
+          is_all_day: data['isAllDay'] || false,
+          organizer: parse_organizer(data['organizer']),
+          attendees: parse_attendees(data['attendees'])
+        }
+      end
+
+      def self.detail_attrs(data)
+        {
+          body_preview: data['bodyPreview'] || strip_html(data.dig('body', 'content')),
+          online_meeting_url: data.dig('onlineMeeting', 'joinUrl'),
+          show_as: data['showAs'],
+          importance: data['importance'],
+          is_cancelled: data['isCancelled'] || false,
+          response_status: data.dig('responseStatus', 'response'),
+          sensitivity: data['sensitivity'],
+          event_type: data['type']
+        }
+      end
+
+      def self.parse_organizer(organizer_data)
+        return nil unless organizer_data
+
+        email_data = organizer_data['emailAddress'] || {}
+        { name: email_data['name'], email: email_data['address'] }
+      end
+
+      def self.parse_attendees(attendees_data)
+        return [] unless attendees_data.is_a?(Array)
+
+        attendees_data.map do |att_data|
+          email_data = att_data['emailAddress'] || {}
+          {
+            name: email_data['name'],
+            email: email_data['address'],
+            type: att_data['type'],
+            response: att_data.dig('status', 'response')
+          }
+        end
+      end
+
+      def short_hash = Digest::SHA256.hexdigest(id.to_s)[0, 6]
+
+      def to_json_hash
+        to_h.merge(start_time: start_time&.iso8601, end_time: end_time&.iso8601)
+      end
+
+      def all_day? = is_all_day
+      def cancelled? = is_cancelled
+      def recurring? = %w[occurrence exception].include?(event_type)
+
+      def time_range_display
+        return 'ALL DAY' if all_day?
+        return '' unless start_time && end_time
+
+        "#{start_time.strftime('%H:%M')}-#{end_time.strftime('%H:%M')}"
+      end
+
+      def date_display
+        if all_day?
+          "#{start_time&.strftime('%Y-%m-%d')} (all day)"
+        elsif start_time && end_time
+          "#{start_time.strftime('%Y-%m-%d %H:%M')}-#{end_time.strftime('%H:%M')}"
+        end
+      end
+
+      def create_summary_lines
+        lines = []
+        lines << date_display if date_display
+        lines << "Location: #{location}" if location && !location.empty?
+        lines << "Teams link: #{online_meeting_url}" if online_meeting_url
+        lines
+      end
+
+      def required_attendees = attendees.select { |att| att[:type] == 'required' }
+      def optional_attendees = attendees.select { |att| att[:type] == 'optional' }
+      def accepted_attendees = attendees.select { |att| att[:response] == 'accepted' }
+      def declined_attendees = attendees.select { |att| att[:response] == 'declined' }
+      def tentative_attendees = attendees.select { |att| att[:response] == 'tentativelyAccepted' }
+      def pending_attendees = attendees.select { |att| PENDING_RESPONSES.include?(att[:response]) }
+    end
+  end
+end