teems 0.1.0

data/lib/teems/commands/who.rb

@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+
+module Teems
+  module Commands
+    # Schedule bitmap rendering for who command
+    module WhoSchedule
+      SLOT_CHARS = { '0' => "\u2591", '1' => "\u2592", '2' => "\u2588", '3' => "\u2593", '4' => "\u2592" }.freeze
+      SLOTS_PER_HOUR = 4
+      DEFAULT_WORK_HOURS = [9, 17].freeze
+      STATUS_LABELS = { 'Available' => 'Available', 'Busy' => 'Busy', 'DoNotDisturb' => 'Do Not Disturb',
+                        'BeRightBack' => 'Be Right Back', 'Away' => 'Away', 'Offline' => 'Offline' }.freeze
+
+      # Bundles email + timezone for schedule lookups
+      ScheduleTarget = Data.define(:email, :timezone)
+      # Bundles schedule display parameters including availability view
+      ScheduleContext = Data.define(:view, :work_start, :tz_abbrev)
+
+      private
+
+      def fetch_schedule(target, work_start, work_end)
+        request_schedule(target, schedule_time_range(work_start, work_end))
+      rescue ApiError => e
+        debug("Could not fetch schedule for #{target.email}: #{e.message}")
+        nil
+      end
+
+      def request_schedule(target, time_range)
+        tr = { start_time: time_range.first, end_time: time_range.last, timezone: target.timezone }
+        with_token_refresh { runner.users_api.schedule(target.email, time_range: tr) }
+      end
+
+      def schedule_time_range(work_start, work_end)
+        [work_start, work_end].map { |hour| "#{Time.now.strftime('%Y-%m-%d')}T#{format('%02d', hour)}:00:00" }
+      end
+
+      def render_schedule(schedule, ctx)
+        view = schedule['availabilityView']
+        return unless view && !view.empty?
+
+        puts "  Today       #{render_bitmap(view)}"
+        puts "              #{render_hour_labels(view, ctx.work_start)}"
+        render_now_marker(ctx.with(view: view))
+      end
+
+      def render_bitmap(view)
+        view.chars.map { |ch| SLOT_CHARS[ch] || ch }.join
+      end
+
+      def render_hour_labels(view, work_start)
+        total_hours = view.length / SLOTS_PER_HOUR
+        (0...total_hours).map { |idx| format_hour_label(work_start + idx) }.join
+      end
+
+      def format_hour_label(hour) = (((hour - 1) % 12) + 1).to_s.ljust(SLOTS_PER_HOUR)
+
+      def render_now_marker(ctx)
+        slot_index = slot_for_now(ctx.work_start)
+        return unless slot_index >= 0 && slot_index < ctx.view.length
+
+        debug("Now marker at slot #{slot_index}")
+        local_time = Time.now.strftime('%-I:%M %p')
+        puts "              #{' ' * slot_index}^ now #{local_time} #{ctx.tz_abbrev}"
+      end
+
+      def render_calendar_line(schedule, ctx)
+        view = schedule['availabilityView']
+        return unless view && !view.empty?
+
+        status_text = compute_cal_status(ctx.with(view: view))
+        puts "  Calendar    #{status_text}" if status_text
+      end
+
+      def compute_cal_status(ctx)
+        view = ctx.view
+        slot = slot_for_now(ctx.work_start)
+        return nil unless slot >= 0 && slot < view.length
+
+        format_cal_label(view, slot, ctx)
+      end
+
+      def format_cal_label(view, slot, ctx)
+        label = view[slot] == '0' ? 'Free' : 'Busy'
+        "#{label}#{next_change_label(view, slot, ctx)}"
+      end
+
+      def next_change_label(view, slot, ctx)
+        next_slot = find_next_change(view, slot)
+        return '' unless next_slot
+
+        change_time = slot_to_time(ctx.work_start, next_slot)
+        " until #{change_time.strftime('%-I:%M %p')} #{ctx.tz_abbrev}"
+      end
+
+      def slot_to_time(work_start, slot_index)
+        offset = (work_start * 60) + (slot_index * 15)
+        Date.today.to_time + (offset * 60)
+      end
+
+      def slot_for_now(work_start)
+        now = Time.now
+        (((now.hour - work_start) * 60) + now.min) / 15
+      end
+
+      def find_next_change(view, start_slot)
+        offset = start_slot + 1
+        match = search_view(view, offset, change_pattern(view[start_slot]))
+        match && (offset + match)
+      end
+
+      def search_view(view, offset, pattern) = view[offset..]&.index(pattern)
+      def change_pattern(slot_char) = free_slot?(slot_char) ? /[^0]/ : /0/
+      def free_slot?(char) = char == '0'
+      def parse_work_hours(schedule) = [parse_hour(schedule, 'startTime', 9), parse_hour(schedule, 'endTime', 17)]
+
+      def parse_hour(schedule, key, default)
+        value = schedule.dig('workingHours', key)
+        value ? value.split(':').first.to_i : default
+      end
+
+      def fetch_schedule_for(target)
+        return nil unless target.email
+
+        schedule = fetch_schedule(target, *DEFAULT_WORK_HOURS)
+        schedule && refetch_if_custom_hours(schedule, target)
+      end
+
+      def refetch_if_custom_hours(schedule, target)
+        actual_hours = parse_work_hours(schedule)
+        return schedule if actual_hours == DEFAULT_WORK_HOURS
+
+        fetch_schedule(target, *actual_hours) || schedule
+      end
+    end
+
+    # Presence display helpers for who command
+    module WhoPresence
+      private
+
+      def render_presence_info(presence_data)
+        return unless presence_data
+
+        if presence_data.dig('presence', 'calendarData', 'isOutOfOffice')
+          render_oof_status(presence_data)
+        else
+          render_normal_status(presence_data)
+        end
+      end
+
+      def render_oof_status(presence_data)
+        render_normal_status(presence_data)
+        expiry = format_presence_expiry(presence_data)
+        text = expiry ? "Out of office (#{expiry})" : 'Out of office'
+        puts "  OOF         #{text}"
+      end
+
+      def render_normal_status(presence_data)
+        label = presence_label(presence_data)
+        text = label_with_expiry(label, format_presence_expiry(presence_data))
+        puts "  Status      #{text}" if label
+      end
+
+      def presence_label(presence_data)
+        availability = presence_data.dig('presence', 'availability')
+        WhoSchedule::STATUS_LABELS[availability] || availability
+      end
+
+      def label_with_expiry(label, expiry)
+        expiry ? "#{label} (#{expiry})" : label
+      end
+
+      def format_presence_expiry(presence_data)
+        expiry_str = presence_data.dig('presence', 'forcedAvailability', 'expiry')
+        return nil unless expiry_str
+
+        parse_expiry_time(expiry_str)
+      end
+
+      def parse_expiry_time(expiry_str)
+        expiry = Time.parse(expiry_str).localtime
+        "until #{expiry.strftime('%b %-d')}"
+      rescue ArgumentError
+        debug("Could not parse presence expiry: #{expiry_str.inspect}")
+        nil
+      end
+    end
+
+    # Profile display helpers for who command
+    module WhoDisplay
+      private
+
+      def render_profile(profile)
+        puts output.bold(profile.best_name)
+        render_profile_fields(profile)
+        render_phones(profile)
+        render_availability(profile)
+      end
+
+      def render_profile_fields(profile)
+        render_field('Email', profile.email)
+        render_field('Title', profile.job_title)
+        render_field('Department', profile.department)
+        render_field('Office', profile.office_location)
+      end
+
+      def render_field(label, value)
+        puts "  #{label.ljust(11)} #{value}" if present?(value)
+      end
+
+      def render_phones(profile)
+        render_field('Phone', profile.business_phones&.first)
+        render_field('Mobile', profile.mobile_phone)
+      end
+
+      def render_availability(profile)
+        presence_data = fetch_presence_data(profile.id)
+        render_presence_info(presence_data)
+        render_schedule_info(profile.email)
+      end
+
+      def render_schedule_info(email)
+        schedule = fetch_schedule_for(WhoSchedule::ScheduleTarget.new(email: email, timezone: detect_timezone))
+        return unless schedule
+
+        ctx = build_schedule_context(schedule)
+        render_calendar_line(schedule, ctx)
+        render_schedule(schedule, ctx)
+      end
+
+      def build_schedule_context(schedule)
+        work_start, = parse_work_hours(schedule)
+        WhoSchedule::ScheduleContext.new(view: schedule['availabilityView'],
+                                         work_start: work_start, tz_abbrev: short_tz_label)
+      end
+
+      def render_search_result(profile, index)
+        name, title, email = profile.search_display
+        title_suffix = present?(title) ? " (#{title})" : ''
+        puts "  #{index + 1}. #{name}#{title_suffix}"
+        puts "     #{email}" if present?(email)
+      end
+
+      def render_search_list(results)
+        results.each_with_index do |profile, index|
+          render_search_result(profile, index)
+        end
+      end
+
+      def search_results_json(results)
+        results.map(&:to_h)
+      end
+
+      def present?(value)
+        value && !value.empty?
+      end
+    end
+
+    # Look up a user's profile
+    class Who < Base
+      include Support::Timezone
+      include WhoSchedule
+      include WhoPresence
+      include WhoDisplay
+
+      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
+
+        lookup_user
+      end
+
+      protected
+
+      def help_text
+        <<~HELP
+          #{output.bold('teems who')} - Look up a user's profile
+
+          #{output.bold('USAGE:')}
+            teems who [options]              Show your profile
+            teems who <query> [options]      Search for a user
+
+          #{output.bold('OPTIONS:')}
+            -v, --verbose    Show debug output
+            -q, --quiet      Suppress output
+            --json           Output as JSON
+            -h, --help       Show this help
+
+          #{output.bold('EXAMPLES:')}
+            teems who                # Show your own profile
+            teems who john           # Search for "john"
+            teems who john@co.com    # Look up by email
+            teems who --json         # Your profile as JSON
+        HELP
+      end
+
+      private
+
+      def lookup_user
+        dispatch_lookup(positional_args.join(' '))
+      rescue ApiError => e
+        error("Failed to look up user: #{e.message}")
+        1
+      end
+
+      def dispatch_lookup(query)
+        query.empty? ? show_current_user : search_users(query)
+      end
+
+      def show_current_user
+        profile = with_token_refresh { runner.users_api.me }
+        display_profile(profile)
+        0
+      end
+
+      def search_users(query)
+        results = with_token_refresh { runner.users_api.search(query) }
+        handle_search_results(results, query)
+        0
+      end
+
+      def handle_search_results(results, query)
+        if results.empty?
+          puts "No users found matching '#{query}'"
+        elsif results.length == 1
+          display_profile(results.first)
+        else
+          display_search_results(results)
+        end
+      end
+
+      def display_profile(profile)
+        @options[:json] ? output_json(json_profile(*profile.json_attrs)) : render_profile(profile)
+      end
+
+      def display_search_results(results)
+        @options[:json] ? output_json(search_results_json(results)) : render_search_list(results)
+      end
+
+      def fetch_presence_data(user_id)
+        return nil unless user_id
+
+        fetch_teams_presence("8:orgid:#{user_id}")
+      rescue ApiError => e
+        debug("Could not fetch presence for #{user_id}: #{e.message}")
+        nil
+      end
+
+      def fetch_teams_presence(mri)
+        result = with_token_refresh { runner.users_api.teams_presence(mri) }
+        result&.first
+      end
+
+      def schedule_target(email) = WhoSchedule::ScheduleTarget.new(email: email, timezone: detect_timezone)
+
+      def json_profile(attrs, user_id)
+        presence_data = fetch_presence_data(user_id)
+        schedule = fetch_schedule_for(schedule_target(attrs[:email]))
+        build_json_profile(attrs, presence_data, schedule)
+      end
+
+      def build_json_profile(attrs, presence_data, schedule)
+        result = attrs.merge(presence: presence_data&.dig('presence', 'availability'),
+                             out_of_office: presence_data&.dig('presence', 'calendarData', 'isOutOfOffice'))
+        return result unless schedule
+
+        result.merge(availability_view: schedule['availabilityView'], working_hours: schedule['workingHours'])
+      end
+    end
+  end
+end

data/lib/teems/formatters/calendar_formatter.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # Attendee formatting helpers for calendar events
+    module CalendarAttendeeFormatter
+      RESPONSE_LABELS = {
+        'accepted' => 'Accepted',
+        'declined' => 'Declined',
+        'tentativelyAccepted' => 'Tentative',
+        'none' => 'Pending'
+      }.freeze
+
+      RESPONSE_SYMBOLS = {
+        'accepted' => [:green, "\u{2713}"], 'declined' => [:red, "\u{2717}"],
+        'tentativelyAccepted' => [:yellow, '?']
+      }.freeze
+
+      private
+
+      def format_attendee_sections(event)
+        [].concat(format_attendee_group('Required Attendees:', event.required_attendees, event))
+          .concat(format_attendee_group('Optional Attendees:', event.optional_attendees, event))
+          .concat(format_untyped_attendees(event))
+      end
+
+      def format_attendee_group(title, attendees, event)
+        return [] unless attendees.any?
+
+        [@output.bold(title), *attendees.map { |attendee| format_attendee(attendee, event) }, '']
+      end
+
+      def format_untyped_attendees(event)
+        untyped = event.attendees.reject { |attendee| %w[required optional].include?(attendee[:type]) }
+        format_attendee_group('Attendees:', untyped, event)
+      end
+
+      def format_attendee(attendee, event)
+        symbol = attendee_symbol(attendee, event)
+        label = response_label(attendee[:response])
+        display = format_name_email(attendee[:name], attendee[:email])
+        "  #{symbol} #{display} \u2014 #{label}"
+      end
+
+      def format_name_email(name, email)
+        name ? "#{@output.bold(name)} (#{email})" : email.to_s
+      end
+
+      def attendee_symbol(att, event)
+        organizer = event.organizer
+        if organizer && att[:email]&.downcase == organizer[:email]&.downcase
+          @output.cyan("\u{2605}")
+        else
+          response_to_symbol(att[:response])
+        end
+      end
+
+      def response_to_symbol(response)
+        color, symbol = RESPONSE_SYMBOLS.fetch(response, [:gray, "\u{B7}"])
+        @output.public_send(color, symbol)
+      end
+
+      def response_label(response)
+        RESPONSE_LABELS[response] || response&.capitalize || 'Pending'
+      end
+    end
+
+    # Detail view formatting for calendar events
+    module CalendarDetailFormatter
+      private
+
+      def detail_metadata_lines(event)
+        lines = [@output.bold(event.subject), format_detail_time(event)]
+        lines.concat(detail_field_lines(event))
+      end
+
+      def detail_field_lines(event)
+        [detail_location(event), detail_organizer(event), detail_link(event),
+         detail_status(event), detail_response(event), detail_recurrence(event),
+         detail_show_as(event)].compact
+      end
+
+      def detail_location(event)
+        loc = event.location
+        return unless loc && !loc.empty?
+
+        "  #{@output.gray('Location:')}  #{loc}"
+      end
+
+      def detail_organizer(event)
+        org = event.organizer
+        return unless org
+
+        "  #{@output.gray('Organizer:')} #{@output.bold(org[:name])} (#{org[:email]})"
+      end
+
+      def detail_link(event)
+        url = event.online_meeting_url
+        return unless url
+
+        "  #{@output.gray('Link:')}      #{url}"
+      end
+
+      def detail_status(event) = event.cancelled? ? "  Status:    #{@output.red('CANCELLED')}" : nil
+
+      def detail_response(event)
+        response = event.response_status
+        return nil unless response
+
+        "  RSVP:      #{response_to_symbol(response)} #{response_label(response)}"
+      end
+
+      def detail_recurrence(event)
+        return unless event.recurring?
+
+        "  #{@output.gray('Recurring:')} Yes"
+      end
+
+      def detail_show_as(event)
+        show_as = event.show_as
+        return unless show_as
+
+        "  #{@output.gray('Show as:')}   #{show_as}"
+      end
+
+      def detail_body_section(event)
+        preview = event.body_preview.to_s.strip
+        return [] if preview.empty?
+
+        [@output.bold('Description:'), "  #{preview}", '']
+      end
+
+      def format_detail_time(event)
+        time_label = @output.gray('Time:')
+        "  #{time_label}      #{detail_time_value(event)}"
+      end
+
+      def detail_time_value(event)
+        return @output.bold('ALL DAY') if event.all_day?
+
+        start_time = event.start_time
+        range_display = event.time_range_display
+        return '(unknown)' unless start_time && range_display != ''
+
+        "#{@output.bold(start_time.strftime('%A, %B %-d, %Y'))}  #{@output.gray(range_display)}"
+      end
+    end
+
+    # Formats calendar events for terminal display
+    class CalendarFormatter
+      include CalendarAttendeeFormatter
+      include CalendarDetailFormatter
+
+      RSVP_COUNTS = %i[accepted declined tentative pending].freeze
+
+      def initialize(output:)
+        @output = output
+      end
+
+      # Compact agenda listing
+      def format_event_list_compact(events)
+        events.each_with_index.map { |event, index| build_list_item_line(event, index + 1) }.join("\n")
+      end
+
+      # Verbose agenda listing with organizer and RSVP summaries
+      def format_event_list_verbose(events)
+        events.each_with_index.flat_map do |event, index|
+          [build_list_item_line(event, index + 1) + list_item_verbose_suffix(event), '']
+        end.join("\n")
+      end
+
+      # Detailed view of a single event
+      def format_event_detail(event)
+        [*detail_metadata_lines(event), '', *detail_body_section(event), *format_attendee_sections(event)].join("\n")
+      end
+
+      private
+
+      def build_list_item_line(event, number)
+        time = event.all_day? ? 'ALL DAY   ' : event.time_range_display.ljust(11)
+        rsvp = response_to_symbol(event.response_status)
+        prefix = "  #{@output.cyan("[#{number}]")} #{@output.gray("[#{event.short_hash}]")} #{time} #{rsvp}"
+        "#{prefix} #{format_event_subject(event)}#{list_item_location(event)}"
+      end
+
+      def format_event_subject(event)
+        title = event.subject
+        suffix = subject_suffix(event)
+        suffix ? "#{title} #{suffix}" : title
+      end
+
+      def subject_suffix(event)
+        return @output.gray('(cancelled)') if event.cancelled?
+
+        @output.gray('(recurring)') if event.recurring?
+      end
+
+      def list_item_location(event) = (loc = event.location) && !loc.empty? ? "  #{@output.gray("(#{loc})")}" : ''
+
+      def list_item_verbose_suffix(event)
+        items = verbose_suffix_parts(event)
+        return '' if items.empty?
+
+        "\n      #{items.join("  #{@output.gray('|')}  ")}"
+      end
+
+      def verbose_suffix_parts(event)
+        [organizer_label(event), attendee_rsvp_summary(event)].compact.reject(&:empty?)
+      end
+
+      def organizer_label(event)
+        organizer = event.organizer
+        return unless organizer
+
+        "#{@output.gray('Organizer:')} #{organizer[:name]}"
+      end
+
+      def attendee_rsvp_summary(event)
+        counts = RSVP_COUNTS.filter_map do |status|
+          count = event.public_send(:"#{status}_attendees").length
+          "#{count} #{@output.gray(status.to_s)}" if count.positive?
+        end
+        counts.join(', ')
+      end
+    end
+  end
+end

data/lib/teems/formatters/format_utils.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # Shared stateless formatting utilities used across commands and formatters
+    module FormatUtils
+      module_function
+
+      def truncate(text, max = 120)
+        text.length > max ? "#{text[0...max]}..." : text
+      end
+
+      def format_bytes(bytes)
+        if bytes >= 1_048_576 then "#{(bytes / 1_048_576.0).round(1)} MB"
+        elsif bytes >= 1024 then "#{(bytes / 1024.0).round(1)} KB"
+        else "#{bytes} B"
+        end
+      end
+
+      def safe_filename(name)
+        base = File.basename(name)
+        base.empty? ? 'file' : base
+      end
+
+      def attachment_name(att)
+        att.is_a?(Hash) ? (att['fileName'] || att['name'] || 'file') : att.to_s
+      end
+
+      def format_single_reaction(reaction, emoji_map)
+        type = reaction[:type]
+        emoji = emoji_map[type] || type
+        count = reaction[:count] || 1
+        count > 1 ? "#{emoji}(#{count})" : emoji.to_s
+      end
+
+      def format_time(time_string)
+        return '' unless time_string
+
+        Time.parse(time_string).getlocal.strftime('[%Y-%m-%d %H:%M]')
+      rescue ArgumentError
+        ''
+      end
+
+      def format_end_time(start_time, end_time)
+        fmt = (end_time - start_time) >= 86_400 ? '%b %-d, %-I:%M %p' : '%-I:%M %p'
+        end_time.strftime(fmt)
+      end
+
+      def build_time_range(start_str, end_match)
+        start_time = Time.parse(start_str).getlocal
+        end_time = end_match ? Time.parse(end_match[1]).getlocal : nil
+        [start_time, end_time]
+      end
+    end
+  end
+end