teems 0.1.0

data/lib/teems/commands/ooo.rb

@@ -0,0 +1,385 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Teems
+  module Commands
+    OOO_HELP = <<~HELP
+      teems ooo - Manage out-of-office status
+
+      USAGE:
+        teems ooo                Show current OOO status
+        teems ooo on [options]   Enable out-of-office
+        teems ooo off            Disable out-of-office
+        teems ooo config         Show OOO configuration
+
+      ON OPTIONS:
+        --message TEXT       Auto-reply and status message
+        --start DATE         Schedule start (YYYY-MM-DD), enables scheduled mode
+        --end DATE           Schedule end (YYYY-MM-DD), required with --start
+        --event              Create an all-day OOO calendar event for notify list
+        --no-status          Skip setting Teams status/presence
+
+      CONFIGURATION:
+        Edit ~/.config/teems/config.json to set defaults:
+
+        {
+          "ooo": {
+            "internal_message": "I'm currently out of office.",
+            "external_message": "Thank you for your message. I'm out of office.",
+            "external_audience": "all",
+            "status_message": "Out of Office",
+            "notify": ["manager@example.com", "team@example.com"]
+          }
+        }
+
+      EXAMPLES:
+        teems ooo                          # Check OOO status
+        teems ooo on                       # Enable OOO (always on)
+        teems ooo on --message "Vacation"  # Custom message
+        teems ooo on --start 2026-04-14 --end 2026-04-18
+        teems ooo off                      # Disable OOO
+        teems ooo config                   # Show config
+    HELP
+
+    # Displays current OOO status (auto-reply + presence)
+    module OooDisplay
+      private
+
+      def show_status
+        replies = fetch_auto_replies
+        presence = fetch_presence
+        render_ooo_status(replies, presence)
+        0
+      end
+
+      def fetch_auto_replies
+        with_token_refresh { runner.users_api.auto_replies }
+      rescue ApiError => e
+        debug("Auto-reply fetch failed: #{e.message}")
+        nil
+      end
+
+      def fetch_presence
+        with_token_refresh { runner.users_api.my_presence }
+      rescue ApiError => e
+        debug("Presence fetch failed: #{e.message}")
+        nil
+      end
+
+      def render_ooo_status(replies, presence)
+        if @options[:json]
+          output_json({ auto_replies: replies, presence: presence })
+        else
+          render_ooo_text(replies, presence)
+        end
+      end
+
+      def render_ooo_text(replies, presence)
+        render_auto_reply_status(replies)
+        render_presence_status(presence)
+      end
+
+      def render_auto_reply_status(replies)
+        return puts('Auto-replies: unknown (permission denied)') unless replies
+
+        status = replies['status'] || 'disabled'
+        puts "Auto-replies: #{status}"
+        render_schedule(replies) if status == 'scheduled'
+        render_reply_message(replies)
+      end
+
+      def render_schedule(replies)
+        start_dt = replies.dig('scheduledStartDateTime', 'dateTime')
+        end_dt = replies.dig('scheduledEndDateTime', 'dateTime')
+        puts "  Schedule: #{format_dt(start_dt)} to #{format_dt(end_dt)}" if start_dt
+      end
+
+      def format_dt(raw)
+        Time.parse(raw).strftime('%Y-%m-%d %H:%M')
+      rescue ArgumentError
+        raw.to_s
+      end
+
+      def render_reply_message(replies)
+        plain = strip_reply_html(replies['internalReplyMessage'])
+        puts "  Message: #{plain[0..80]}" unless plain.empty?
+      end
+
+      def strip_reply_html(raw) = raw.to_s.gsub(/<[^>]+>/, '').strip
+
+      def render_presence_status(presence)
+        return unless presence
+
+        availability = presence['availability'] || 'Unknown'
+        puts "Presence: #{availability}"
+        msg = presence.dig('statusMessage', 'message', 'content')
+        puts "  Status: #{msg}" if msg && !msg.empty?
+      end
+    end
+
+    # Enables/disables OOO: auto-reply, status message, presence, calendar event
+    module OooActions
+      private
+
+      def enable_ooo
+        result = validate_create_options
+        return result if result
+
+        results = execute_ooo_steps
+        summarize_results(results)
+        results.values.all? ? 0 : 1
+      end
+
+      def disable_ooo
+        results = {}
+        results[:auto_reply] = disable_auto_reply
+        results[:status] = clear_ooo_status unless @options[:no_status]
+        summarize_disable_results(results)
+        results.values.all? ? 0 : 1
+      end
+
+      def validate_create_options
+        validate_schedule_dates || validate_date_format(:start) || validate_date_format(:end)
+      end
+
+      def validate_schedule_dates
+        return unless @options[:start] && !@options[:end]
+
+        error('--end is required when using --start')
+        1
+      end
+
+      def validate_date_format(key)
+        value = @options[key]
+        return unless value
+
+        Date.parse(value)
+        nil
+      rescue ArgumentError
+        error("Invalid date for --#{key}: #{value}. Expected format: YYYY-MM-DD")
+        1
+      end
+
+      def execute_ooo_steps
+        results = {}
+        results[:auto_reply] = set_auto_reply
+        results[:status] = set_ooo_status unless @options[:no_status]
+        results[:event] = create_ooo_event if @options[:event] && !notify_list.empty?
+        results
+      end
+
+      def set_auto_reply
+        settings = build_auto_reply_settings
+        with_token_refresh { runner.users_api.update_auto_replies(settings) }
+        success('Auto-reply enabled')
+        true
+      rescue ApiError => e
+        warn_step('auto-reply', e)
+        false
+      end
+
+      def disable_auto_reply
+        with_token_refresh { runner.users_api.update_auto_replies(status: 'disabled') }
+        success('Auto-reply disabled')
+        true
+      rescue ApiError => e
+        warn_step('auto-reply', e)
+        false
+      end
+
+      def set_ooo_status
+        message = status_message_text
+        apply_ooo_presence(message)
+        success("Status set: #{message}")
+        true
+      rescue ApiError => e
+        warn_step('status/presence', e)
+        false
+      end
+
+      def apply_ooo_presence(message)
+        users = runner.users_api
+        with_token_refresh { users.set_status_message(message: message, expiry: nil) }
+        with_token_refresh { users.set_presence(availability: 'Offline', activity: 'OffWork', duration: 'PT8H') }
+      end
+
+      def clear_ooo_status
+        users = runner.users_api
+        with_token_refresh { users.clear_status_message }
+        with_token_refresh { users.clear_presence }
+        success('Status and presence cleared')
+        true
+      rescue ApiError => e
+        warn_step('status/presence', e)
+        false
+      end
+
+      def create_ooo_event
+        body = build_ooo_event
+        with_token_refresh { runner.calendar_api.create_event(body) }
+        success("Calendar event created for #{notify_list.length} recipient(s)")
+        true
+      rescue ApiError => e
+        warn_step('calendar event', e)
+        false
+      end
+
+      def warn_step(step, err)
+        output.warn("#{step}: #{err.message}")
+      end
+    end
+
+    # Builds API request bodies for OOO operations
+    module OooBuildHelpers
+      private
+
+      def build_auto_reply_settings
+        msg = auto_reply_message
+        settings = { status: auto_reply_status,
+                     internalReplyMessage: msg,
+                     externalReplyMessage: external_message(msg),
+                     externalAudience: ooo_config('external_audience') || 'all' }
+        add_schedule(settings) if @options[:start]
+        settings
+      end
+
+      def auto_reply_status
+        @options[:start] ? 'scheduled' : 'alwaysEnabled'
+      end
+
+      def auto_reply_message
+        @options[:message] || ooo_config('internal_message') || 'I am currently out of office.'
+      end
+
+      def external_message(internal_fallback)
+        ooo_config('external_message') || internal_fallback
+      end
+
+      def status_message_text
+        @options[:message] || ooo_config('status_message') || 'Out of Office'
+      end
+
+      def add_schedule(settings)
+        tz = detect_timezone
+        settings[:scheduledStartDateTime] = { dateTime: "#{@options[:start]}T00:00:00", timeZone: tz }
+        settings[:scheduledEndDateTime] = { dateTime: "#{@options[:end]}T23:59:59", timeZone: tz }
+      end
+
+      def build_ooo_event
+        { subject: status_message_text,
+          start: ooo_event_time(:start),
+          end: ooo_event_time(:end),
+          isAllDay: true,
+          showAs: 'free',
+          isReminderOn: false,
+          isOnlineMeeting: false,
+          transactionId: SecureRandom.uuid,
+          attendees: notify_list.map { |email| ooo_attendee(email) },
+          responseRequested: false }
+      end
+
+      def ooo_event_time(field)
+        date = @options[field] || Date.today.to_s
+        end_date = field == :end ? (Date.parse(date) + 1).to_s : date
+        tz = detect_timezone
+        { dateTime: "#{end_date}T00:00:00", timeZone: tz }
+      end
+
+      def ooo_attendee(email)
+        { emailAddress: { address: email }, type: 'required' }
+      end
+
+      def notify_list
+        @notify_list ||= ooo_config('notify') || []
+      end
+
+      def ooo_config(key)
+        config['ooo']&.dig(key)
+      end
+    end
+
+    # Manage out-of-office: auto-reply, status, presence, and calendar event
+    class Ooo < Base
+      include Support::Timezone
+      include OooDisplay
+      include OooActions
+      include OooBuildHelpers
+
+      def initialize(args, runner:)
+        @options = {}
+        super
+      end
+
+      OOO_OPTIONS = {
+        '--message' => ->(opts, args) { opts[:message] = args.shift },
+        '--start' => ->(opts, args) { opts[:start] = args.shift },
+        '--end' => ->(opts, args) { opts[:end] = args.shift },
+        '--event' => ->(opts, _args) { opts[:event] = true },
+        '--no-status' => ->(opts, _args) { opts[:no_status] = true }
+      }.freeze
+
+      OOO_ACTIONS = {
+        'on' => :enable_ooo, 'off' => :disable_ooo,
+        'config' => :show_config
+      }.freeze
+
+      def execute
+        result = validate_options
+        return result if result
+
+        auth_result = require_auth
+        return auth_result if auth_result
+
+        dispatch_action
+      end
+
+      protected
+
+      def handle_option(arg, pending)
+        handler = OOO_OPTIONS[arg]
+        return super unless handler
+
+        handler.call(@options, pending)
+      end
+
+      def help_text = OOO_HELP
+
+      private
+
+      def dispatch_action
+        action = positional_args.first
+        method_name = OOO_ACTIONS[action]
+        return send(method_name) if method_name
+        return show_status unless action
+
+        error("Unknown action: #{action}. Use: on, off, config")
+        1
+      end
+
+      def show_config
+        ooo = config['ooo'] || {}
+        if @options[:json]
+          output_json(ooo)
+        else
+          puts ooo.empty? ? 'No OOO config set. See: teems ooo --help' : JSON.pretty_generate(ooo)
+        end
+        0
+      end
+
+      def summarize_results(results)
+        return if results.values.all?
+
+        output.warn("OOO partially enabled: #{count_successes(results)}/#{results.size} steps succeeded")
+      end
+
+      def summarize_disable_results(results)
+        return if results.values.all?
+
+        output.warn("OOO partially disabled: #{count_successes(results)}/#{results.size} steps succeeded")
+      end
+
+      def count_successes(results) = results.values.count(true)
+    end
+  end
+end

data/lib/teems/commands/org.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+module Teems
+  module Commands
+    # Walks manager chain and direct reports tree
+    module OrgTreeWalker
+      private
+
+      def walk_manager_chain(target_id)
+        managers = []
+        current_id = target_id
+        fetch = method(target_is_me? ? :fetch_my_manager : :fetch_user_manager)
+        collect_managers(managers, current_id, fetch)
+      end
+
+      def collect_managers(managers, current_id, fetch)
+        while (mgr = fetch.call(current_id))
+          managers.unshift(mgr)
+          current_id = mgr.id
+          fetch = method(:fetch_user_manager)
+        end
+        managers
+      end
+
+      def fetch_my_manager(_user_id)
+        with_token_refresh { runner.users_api.manager_me }
+      rescue ApiError => e
+        raise unless e.not_found?
+
+        nil
+      end
+
+      def fetch_user_manager(user_id)
+        with_token_refresh { runner.users_api.manager(user_id) }
+      rescue ApiError => e
+        raise unless e.not_found?
+
+        nil
+      end
+
+      def walk_reports_tree(user, remaining_depth, fetch)
+        return { user: user, reports: [] } if remaining_depth <= 0
+
+        reports = fetch.call(user.id)
+        children = reports.map { |report| walk_reports_tree(report, remaining_depth - 1, method(:fetch_user_reports)) }
+        { user: user, reports: children }
+      end
+
+      def fetch_my_reports(_user_id)
+        with_token_refresh { runner.users_api.direct_reports_me }
+      rescue ApiError => e
+        handle_reports_error(e, 'direct reports')
+      end
+
+      def fetch_user_reports(user_id)
+        with_token_refresh { runner.users_api.direct_reports(user_id) }
+      rescue ApiError => e
+        handle_reports_error(e, "direct reports for #{user_id}")
+      end
+
+      def handle_reports_error(err, context)
+        debug("Could not fetch #{context}: #{err.message}")
+        raise unless recoverable_reports_error?(err)
+
+        []
+      end
+
+      def recoverable_reports_error?(err) = err.not_found? || err.forbidden?
+
+      def target_is_me?
+        positional_args.empty?
+      end
+    end
+
+    # Renders org chart as text tree or JSON
+    module OrgRenderer
+      # Groups org chart data: managers chain, target user, and reports tree
+      OrgData = Struct.new(:managers, :target, :reports) do
+        def to_json_hash
+          { managers: managers.map(&:to_h), target: target.to_h,
+            direct_reports: self.class.json_reports(reports[:reports]) }
+        end
+
+        def self.json_reports(reports)
+          reports.map { |report| json_report(*report.values_at(:user, :reports)) }
+        end
+
+        def self.json_report(user, sub_reports)
+          user.to_h.merge(direct_reports: json_reports(sub_reports))
+        end
+      end
+
+      private
+
+      def render_org(org_data)
+        if @options[:json]
+          output_json(org_data.to_json_hash)
+        else
+          render_tree(org_data)
+        end
+      end
+
+      def render_tree(org_data)
+        managers = org_data.managers
+        depth = managers.length
+        managers.each_with_index { |mgr, index| puts "#{'  ' * index}#{format_person(mgr)}" }
+        puts "#{'  ' * depth}--> #{format_person(org_data.target)}"
+        render_reports(org_data.reports[:reports], depth + 1)
+      end
+
+      def render_reports(reports, level)
+        reports.each do |node|
+          puts "#{'  ' * level}#{format_person(node[:user])}"
+          render_reports(node[:reports], level + 1)
+        end
+      end
+
+      def format_person(profile)
+        title = profile.job_title
+        name = profile.best_name
+        title && !title.empty? ? "#{name} (#{title})" : name.to_s
+      end
+    end
+
+    # Show org chart for a user
+    class Org < Base
+      include OrgTreeWalker
+      include OrgRenderer
+
+      ORG_OPTIONS = {
+        '--depth' => ->(opts, args) { opts[:depth] = parse_depth(args.shift) }
+      }.freeze
+
+      def self.parse_depth(value)
+        return 1 unless value
+
+        result = value.to_i
+        result >= 0 ? result : 1
+      end
+
+      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
+
+        show_org_chart
+      end
+
+      protected
+
+      def handle_option(arg, pending)
+        handler = ORG_OPTIONS[arg]
+        return super unless handler
+
+        handler.call(@options, pending)
+      end
+
+      def help_text
+        <<~HELP
+          #{output.bold('teems org')} - Show org chart for a user
+
+          #{output.bold('USAGE:')}
+            teems org [options]              Org chart for current user
+            teems org <query> [options]      Org chart for a searched user
+
+          #{output.bold('OPTIONS:')}
+            --depth N        Limit direct report depth (default: 1)
+            -v, --verbose    Show debug output
+            -q, --quiet      Suppress output
+            --json           Output as JSON
+            -h, --help       Show this help
+
+          #{output.bold('EXAMPLES:')}
+            teems org                # Your org chart
+            teems org john           # Org chart for "john"
+            teems org --depth 1      # Only immediate reports
+            teems org --json         # JSON output
+        HELP
+      end
+
+      private
+
+      def show_org_chart
+        target = resolve_target
+        target ? display_org(target) : 1
+      rescue ApiError => e
+        org_fetch_error(e)
+      end
+
+      def org_fetch_error(err)
+        error("Failed to fetch org chart: #{err.message}")
+        1
+      end
+
+      def display_org(target)
+        render_org(fetch_org_data(target))
+        0
+      end
+
+      def fetch_org_data(target)
+        managers = walk_manager_chain(target.id)
+        report_fetch = method(target_is_me? ? :fetch_my_reports : :fetch_user_reports)
+        reports = walk_reports_tree(target, depth, report_fetch)
+        OrgRenderer::OrgData.new(managers: managers, target: target, reports: reports)
+      end
+
+      def depth
+        @options[:depth] || 1
+      end
+
+      def resolve_target
+        query = positional_args.join(' ')
+        query.empty? ? with_token_refresh { runner.users_api.me } : resolve_by_search(query)
+      end
+
+      def resolve_by_search(query)
+        results = with_token_refresh { runner.users_api.search(query) }
+        return results.first unless results.empty?
+
+        error("No users found matching '#{query}'")
+        nil
+      end
+    end
+  end
+end