slk 0.5.0 → 0.7.0

data/lib/slk/services/profile_resolver.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Orchestrates the API calls needed to assemble a Models::Profile.
+    # Memoizes within the instance — one resolver per command run.
+    class ProfileResolver
+      SCHEMA_TTL = 86_400 # 24h
+      PROFILE_TTL = 3_600 # 1h
+      EMPTY_SCHEMA = { 'ok' => false, 'profile' => { 'fields' => [], 'sections' => [] } }.freeze
+
+      attr_accessor :refresh
+
+      def initialize(users_api:, team_api:, cache_store: nil, workspace_name: nil, on_debug: nil)
+        @users_api = users_api
+        @team_api = team_api
+        @cache_store = cache_store
+        @workspace_name = workspace_name
+        @on_debug = on_debug
+        @refresh = false
+        @profile_cache = {}
+        @home_team_names = {}
+      end
+
+      # Resolve a user ID to a Profile. Memoized per resolver instance.
+      def resolve(user_id)
+        return @profile_cache[user_id] if @profile_cache.key?(user_id)
+
+        @profile_cache[user_id] = build_profile(user_id)
+      end
+
+      # Resolve a profile and one level of type:user custom fields, populating
+      # `resolved_users` so the formatter can render the People section.
+      def resolve_with_people(user_id)
+        profile = resolve(user_id)
+        return profile if profile.external?
+
+        profile.people_fields.flat_map(&:user_ids).uniq.each do |ref_id|
+          profile.resolved_users[ref_id] ||= resolve(ref_id)
+        end
+        profile
+      end
+
+      # Walks Supervisor (or first non-inverse type:user field) upward.
+      # Returns Array<Profile> from immediate supervisor to top, capped by depth.
+      def resolve_chain_up(user_id, depth: 5)
+        chain = []
+        seen = Set.new([user_id])
+        current = resolve(user_id)
+        depth.times { current = step_up(current, seen, chain) or break }
+        chain
+      end
+
+      private
+
+      def step_up(current, seen, chain)
+        parent_id = current.supervisor_ids.first
+        return nil unless parent_id && !seen.include?(parent_id)
+
+        parent = resolve(parent_id)
+        chain << parent
+        seen << parent.user_id
+        parent
+      end
+
+      def build_profile(user_id)
+        profile = ProfileBuilder.build(
+          profile_response: fetch_profile_response(user_id),
+          info_response: cache_or_fetch("ui_#{user_id}", ttl: PROFILE_TTL) { @users_api.info(user_id) },
+          schema_response: schema,
+          workspace_team_id: workspace_team_id
+        )
+        attach_extras(profile, user_id)
+      rescue ApiError => e
+        @on_debug&.call("Profile resolve failed for #{user_id}: #{e.message}")
+        raise
+      end
+
+      # Only swallow `user_not_found` (Slack Connect); other errors propagate.
+      def fetch_profile_response(user_id)
+        key = "up_#{user_id}"
+        cached = MetaCache.read(@cache_store, @workspace_name, key, ttl: PROFILE_TTL) unless @refresh
+        return cached if cached
+
+        response = @users_api.profile_for(user_id)
+        MetaCache.write(@cache_store, @workspace_name, key, response)
+        response
+      rescue ApiError => e
+        raise unless e.code == :user_not_found
+
+        @on_debug&.call("#{key}: #{e.message} (falling back to users.info)")
+        nil
+      end
+
+      def attach_extras(profile, user_id)
+        profile = attach_home_team_name(profile)
+        presence = fetch_presence(user_id)
+        presence ? Models::Profile.new(**profile.to_h, presence: presence) : profile
+      end
+
+      def fetch_presence(user_id)
+        @users_api.get_presence_for(user_id)&.dig('presence')
+      rescue ApiError => e
+        @on_debug&.call("get_presence_for(#{user_id}) failed: #{e.message}")
+        nil
+      end
+
+      def schema
+        @schema ||= cache_or_fetch('team_profile_schema', ttl: SCHEMA_TTL,
+                                                          empty: EMPTY_SCHEMA) { @team_api.profile_schema }
+      end
+
+      def workspace_team_id
+        @workspace_team_id ||= cache_or_fetch('workspace_team_id') { @team_api.info.dig('team', 'id') }
+      end
+
+      def cache_or_fetch(key, ttl: nil, empty: nil, &)
+        MetaCache.fetch(@cache_store, @workspace_name, key, ttl: ttl, refresh: @refresh, &)
+      rescue ApiError => e
+        @on_debug&.call("#{key} fetch failed: #{e.message}")
+        empty
+      end
+
+      def attach_home_team_name(profile)
+        return profile unless profile.external? && profile.team_id && (name = home_team_name(profile.team_id))
+
+        Models::Profile.new(**profile.to_h, home_team_name: name)
+      end
+
+      def home_team_name(team_id)
+        @home_team_names[team_id] ||= @team_api.info(team_id).dig('team', 'name')
+      rescue ApiError => e
+        @on_debug&.call("team.info(#{team_id}) failed: #{e.message}")
+        @home_team_names[team_id] = nil
+      end
+    end
+  end
+end

data/lib/slk/services/user_lookup.rb

@@ -52,6 +52,14 @@ module Slk
         fetch_id_by_name(name)
       end
 
+      # @return [Array<Hash>] raw users.list-shaped hashes for all matches
+      def find_all_by_name(name)
+        UserMatcher.new(
+          api_client: @api, workspace: @workspace,
+          cache_store: @cache, on_debug: @on_debug
+        ).find_all(name)
+      end
+
       private
 
       def fetch_and_cache_name(user_id)
@@ -88,11 +96,7 @@ module Slk
       end
 
       def fetch_id_by_name(name)
-        return nil unless @api
-
-        users_api = Api::Users.new(@api, @workspace, on_debug: @on_debug)
-        users = users_api.list['members'] || []
-        user = find_user_by_name(users, name)
+        user = find_all_by_name(name).first
         cache_user_from_api(user) if user
         user&.dig('id')
       rescue ApiError => e
@@ -100,14 +104,6 @@ module Slk
         nil
       end
 
-      def find_user_by_name(users, name)
-        users.find do |u|
-          u['name'] == name ||
-            u.dig('profile', 'display_name') == name ||
-            u.dig('profile', 'real_name') == name
-        end
-      end
-
       def cache_user_from_api(user_data)
         user = Models::User.from_api(user_data)
         @cache.set_user(@workspace.name, user.id, user.best_name, persist: true)

data/lib/slk/services/user_matcher.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Finds all users whose name/display/real/first+last matches a query
+    # (case-insensitive). Combines users.list with previously-resolved profiles
+    # cached locally — Slack Connect external users don't appear in users.list
+    # but do show up in the meta cache once users.info has been fetched.
+    class UserMatcher
+      def initialize(api_client:, workspace:, cache_store:, on_debug: nil)
+        @api = api_client
+        @workspace = workspace
+        @cache = cache_store
+        @on_debug = on_debug
+      end
+
+      # Returns users.list-shaped hashes (deduped by id). Raises ApiError on
+      # network/auth failures so callers don't conflate them with "no matches".
+      def find_all(name)
+        return [] if name.to_s.empty? || @api.nil?
+
+        target = name.downcase
+        candidates = list_members + cached_profile_users
+        unique_by_id(candidates.select { |u| matches?(u, target) })
+      end
+
+      def matches?(user, target_lower)
+        name_candidates(user).any? { |c| c.downcase == target_lower }
+      end
+
+      def name_candidates(user)
+        profile = user['profile'] || {}
+        full = [profile['first_name'], profile['last_name']].compact.join(' ').strip
+        [user['name'], profile['display_name'], profile['real_name'], full]
+          .map(&:to_s).reject(&:empty?)
+      end
+
+      private
+
+      def list_members
+        Api::Users.new(@api, @workspace, on_debug: @on_debug).list['members'] || []
+      end
+
+      # Reshape cached `ui_<uid>` meta entries (raw users.info responses) into
+      # users.list-shaped hashes so the matcher can compare them uniformly.
+      def cached_profile_users
+        return [] unless @cache.respond_to?(:each_meta)
+
+        @cache.each_meta(@workspace.name).filter_map do |key, value|
+          next unless key.start_with?('ui_')
+
+          user = value.is_a?(Hash) ? value.dig('value', 'user') : nil
+          user if user.is_a?(Hash) && user['id']
+        end
+      end
+
+      def unique_by_id(users)
+        seen = {}
+        users.each { |u| seen[u['id']] ||= u }
+        seen.values
+      end
+    end
+  end
+end

data/lib/slk/services/user_picker.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Disambiguates between multiple matching users. Prompts at a TTY; raises
+    # ApiError in non-interactive contexts so callers don't silently get the
+    # wrong user when name resolution is ambiguous.
+    class UserPicker
+      def initialize(stdin: $stdin, prompt_io: $stderr)
+        @stdin = stdin
+        @prompt_io = prompt_io
+      end
+
+      def pick(matches)
+        return matches.first['id'] if matches.size == 1
+
+        unless interactive?
+          raise ApiError,
+                "Ambiguous match (#{matches.size} users): #{ids(matches).join(', ')}. " \
+                'Use --pick N or --all to disambiguate non-interactively.'
+        end
+
+        list(matches)
+        matches[read_index(matches.size)]['id']
+      end
+
+      private
+
+      def interactive?
+        @stdin.respond_to?(:tty?) && @stdin.tty?
+      end
+
+      def list(matches)
+        @prompt_io.puts('Multiple users match — pick one:')
+        matches.each_with_index { |u, i| @prompt_io.puts("  [#{i + 1}] #{describe(u)}") }
+      end
+
+      def describe(user)
+        profile = user['profile'] || {}
+        name = profile['real_name'] || profile['display_name'] || user['name']
+        suffix = profile['title'].to_s.empty? ? '' : " — #{profile['title']}"
+        "#{name} (#{user['id']})#{suffix}#{flag_suffix(user)}"
+      end
+
+      def flag_suffix(user)
+        flags = []
+        flags << 'deactivated' if user['deleted']
+        flags << 'bot' if user['is_bot']
+        flags.empty? ? '' : " [#{flags.join(', ')}]"
+      end
+
+      def ids(matches)
+        matches.map { |u| u['id'] }
+      end
+
+      def read_index(count)
+        loop do
+          @prompt_io.print("Choice [1-#{count}]: ")
+          choice = @stdin.gets&.strip
+          raise ApiError, 'No selection made' if choice.nil? || choice.empty?
+
+          n = Integer(choice, exception: false)
+          return n - 1 if n&.between?(1, count)
+        end
+      end
+    end
+  end
+end

data/lib/slk/services/who_target_resolver.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Resolves the positional target for `slk who` into one or more user_ids.
+    class WhoTargetResolver
+      def initialize(workspace:, cache_store:, api_client:, output:, options:)
+        @workspace = workspace
+        @cache_store = cache_store
+        @api_client = api_client
+        @output = output
+        @options = options
+      end
+
+      def resolve(target)
+        return [self_user_id] if target.nil? || target == 'me'
+        return [target] if target.match?(/\A[UW][A-Z0-9]+\z/)
+
+        ids = resolve_by_name(target.delete_prefix('@'))
+        ids || (raise ApiError, "Could not resolve user: #{target}")
+      end
+
+      private
+
+      def resolve_by_name(name)
+        matches = lookup.find_all_by_name(name)
+        return select(matches) if matches.any?
+
+        cached = @cache_store.get_user_id_by_name(@workspace.name, name)
+        cached ? [cached] : nil
+      end
+
+      def select(matches)
+        return matches.map { |u| u['id'] } if @options[:all]
+        return [pick_by_index(matches)] if @options[:pick]
+
+        [UserPicker.new.pick(matches)]
+      end
+
+      def pick_by_index(matches)
+        idx = @options[:pick]
+        raise ApiError, "--pick #{idx} out of range (got #{matches.size} matches)" unless idx&.between?(1, matches.size)
+
+        matches[idx - 1]['id']
+      end
+
+      def lookup
+        UserLookup.new(
+          cache_store: @cache_store, workspace: @workspace,
+          api_client: @api_client, on_debug: ->(msg) { @output.debug(msg) }
+        )
+      end
+
+      def self_user_id
+        cached = @cache_store.get_meta(@workspace.name, 'self_user_id')
+        return cached if cached
+
+        user_id = Api::Client.new(@api_client, @workspace).auth_test['user_id']
+        @cache_store.set_meta(@workspace.name, 'self_user_id', user_id) if user_id
+        user_id
+      end
+    end
+  end
+end

data/lib/slk/support/time_parser.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'date'
+
+module Slk
+  module Support
+    # Resolves a single clock time ("1:30p", "2026-08-12 8a") to a Unix
+    # timestamp. A bare time at or before now rolls to tomorrow; an explicit
+    # YYYY-MM-DD date is honoured as given.
+    #
+    # TimeRangeParser builds the two-sided form on the clock arithmetic here.
+    class TimeParser
+      TIME = /(\d{1,2})(?::(\d{2}))?\s*([ap]m?)?/i
+      PATTERN = /\A(?:(\d{4}-\d{2}-\d{2})\s+)?#{TIME}\z/i
+
+      EXAMPLE = '1:30p or 2026-08-12 8:00'
+
+      MINUTES_PER_DAY = 24 * 60
+
+      # A bare hour of 0 or 13-23 can only be 24-hour notation, so no am/pm was
+      # omitted. Anything in 1..12 is genuinely ambiguous without one.
+      CLOCK_HOURS = (1..12)
+
+      # @param now [Time] reference point for rolling bare times forward
+      # @return [Integer] Unix timestamp
+      def self.parse(input, now: Time.now) = new(now: now).parse(input)
+
+      def initialize(now: Time.now)
+        @now = now
+      end
+
+      def parse(input)
+        match = PATTERN.match(input.to_s.strip)
+        raise TimeFormatError, "Invalid time: #{input}. Use #{EXAMPLE}" unless match
+
+        parts = match.captures[1..3]
+        date = match[1] ? parse_date(match[1]) : roll_forward(parts)
+        at(date, *parts).to_i
+      end
+
+      # The rest of this class is clock arithmetic shared with TimeRangeParser,
+      # which needs to place the same parts on dates it works out itself.
+
+      # @param example [String] format hint, so a caller with its own syntax
+      #   (TimeRangeParser) does not advertise this class's example
+      def parse_date(text, example: EXAMPLE)
+        Date.parse(text)
+      rescue Date::Error
+        raise TimeFormatError, "Invalid date: #{text}. Use #{example}"
+      end
+
+      def at(date, *parts)
+        hours, minutes = to_24_hour(*parts)
+        time = build(date, hours, minutes)
+        # Ruby silently shifts a local time that DST skips (2:30a on a
+        # spring-forward date becomes 3:30a), which would move the window
+        # rather than fail. Reject it instead.
+        return time if time.hour == hours && time.min == minutes
+
+        raise TimeFormatError,
+              format('%<clock>s does not exist on %<date>s (clocks skip forward for DST).',
+                     clock: format('%<h>02d:%<m>02d', h: hours, m: minutes), date: date)
+      end
+
+      # Same placement without the existence check, for callers asking a
+      # question a nonexistent time still answers. `at` would raise, which for
+      # the roll-forward probe would reject "2:30a" outright on a spring-forward
+      # date instead of rolling it to the next day, where it does exist.
+      def place(date, *parts) = build(date, *to_24_hour(*parts))
+
+      # Minutes since midnight, for comparing two times before either has a date.
+      def minutes(parts)
+        hours, mins = to_24_hour(*parts)
+        (hours * 60) + mins
+      end
+
+      # True when these parts could have meant either am or pm — no meridiem
+      # given, and an hour small enough that both readings are plausible.
+      def ambiguous?(parts) = parts[2].nil? && CLOCK_HOURS.cover?(parts[0].to_i)
+
+      # The opposite: a bare hour too large to be a 12-hour clock reading, so
+      # the writer was plainly using 24-hour notation. TimeRangeParser treats
+      # one of these as settling how to read the *other* side of a range.
+      def twenty_four_hour?(parts) = parts[2].nil? && !CLOCK_HOURS.cover?(parts[0].to_i)
+
+      private
+
+      def build(date, hours, minutes) = Time.new(date.year, date.month, date.day, hours, minutes, 0)
+
+      def roll_forward(parts)
+        today = @now.to_date
+        place(today, *parts) <= @now ? today + 1 : today
+      end
+
+      def to_24_hour(hour, minute, meridiem)
+        hours = hour.to_i
+        minutes = minute.to_i
+        raise TimeFormatError, "Invalid minute: #{minute}" if minutes > 59
+        return [validate_24_hour(hours), minutes] unless meridiem
+
+        [apply_meridiem(hours, meridiem), minutes]
+      end
+
+      def validate_24_hour(hours)
+        raise TimeFormatError, "Invalid hour: #{hours}" if hours > 23
+
+        hours
+      end
+
+      def apply_meridiem(hours, meridiem)
+        raise TimeFormatError, "Invalid hour for 12-hour time: #{hours}" if hours.zero? || hours > 12
+
+        # 12am is hour 0 and 12pm is hour 12, so fold 12 down before shifting.
+        base = hours % 12
+        meridiem[0].casecmp?('p') ? base + 12 : base
+      end
+    end
+  end
+end

data/lib/slk/support/time_range_parser.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'date'
+
+module Slk
+  module Support
+    # Parses a scheduling window ("1:30p-3:30p", "2026-08-04 13:30-15:30")
+    # into a [start, end] pair of Unix timestamps.
+    #
+    # Unlike DateParser, which resolves an input to a point in the past, this
+    # always resolves forward: a bare time at or before now rolls to tomorrow,
+    # and an end before the start rolls to the next day so overnight windows
+    # ("11p-1a") work.
+    #
+    # The start date is written once and the end can only reach the following
+    # day, so this cannot express a multi-day window — `slk status schedule
+    # --start/--end` is the general form for that.
+    class TimeRangeParser
+      RANGE_PATTERN = /\A(?:(\d{4}-\d{2}-\d{2})\s+)?#{TimeParser::TIME}\s*-\s*#{TimeParser::TIME}\z/i
+
+      EXAMPLE = '1:30p-3:30p or 2026-08-04 13:30-15:30'
+
+      # Longest overnight window accepted when a reading had to be guessed.
+      # Twelve hours is not a policy about window length — an explicit
+      # "8p-9a" is longer and fine — it is the point past which a guessed
+      # crossing can no longer be what the user meant.
+      MAX_GUESSED_OVERNIGHT_MINUTES = 12 * 60
+
+      # @param input [String] the range to parse
+      # @param now [Time] reference point for rolling bare times forward
+      # @return [Array(Integer, Integer)] start and end Unix timestamps
+      def self.parse(input, now: Time.now) = new(now: now).parse(input)
+
+      # True when input looks like a time range, used to pick it out of argv.
+      def self.match?(input) = RANGE_PATTERN.match?(input.to_s.strip)
+
+      def initialize(now: Time.now)
+        @now = now
+        @clock = TimeParser.new(now: now)
+      end
+
+      def parse(input)
+        match = RANGE_PATTERN.match(input.to_s.strip)
+        raise TimeFormatError, "Invalid time range: #{input}. Use #{EXAMPLE}" unless match
+
+        start_parts, end_parts = infer_meridiems(match)
+        validate_range(input, start_parts, end_parts)
+
+        date = start_date(match, start_parts)
+        start_at = @clock.at(date, *start_parts)
+
+        [start_at.to_i, end_time(date, start_at, end_parts).to_i]
+      end
+
+      private
+
+      # `match.captures` layout: 0 is the optional date, 1..3 the start time,
+      # 4..6 the end. Note the date is `match[1]` in the 1-indexed MatchData form.
+      #
+      # "1-3p" means 1pm, not 1am: when only one side names a meridiem the
+      # other borrows it. The borrow is skipped when it would invert the range
+      # ("9-5p" is 9am to 5pm, not 9pm to 5pm).
+      def infer_meridiems(match)
+        start_parts = match.captures[1..3]
+        end_parts = match.captures[4..6]
+
+        if borrowable?(start_parts, end_parts)
+          borrowed = with_meridiem(start_parts, end_parts[2])
+          return [borrowed, end_parts] if @clock.minutes(borrowed) < @clock.minutes(end_parts)
+        elsif borrowable?(end_parts, start_parts)
+          borrowed = with_meridiem(end_parts, start_parts[2])
+          return [start_parts, borrowed] if @clock.minutes(start_parts) < @clock.minutes(borrowed)
+        end
+
+        [start_parts, end_parts]
+      end
+
+      def borrowable?(parts, source) = !source[2].nil? && @clock.ambiguous?(parts)
+
+      def with_meridiem(parts, meridiem) = [parts[0], parts[1], meridiem]
+
+      # An explicit date is honoured as given; a bare time at or before now
+      # refers to tomorrow.
+      def start_date(match, start_parts)
+        return @clock.parse_date(match[1], example: EXAMPLE) if match[1]
+
+        today = @now.to_date
+        # `place`, not `at`: this only asks "is that time already past today?",
+        # and on a spring-forward date `at` would reject a skipped time outright
+        # instead of letting it roll to tomorrow, where it exists.
+        @clock.place(today, *start_parts) <= @now ? today + 1 : today
+      end
+
+      def end_time(date, start_at, end_parts)
+        end_at = @clock.at(date, *end_parts)
+        # An end before the start means the window crosses midnight.
+        end_at < start_at ? @clock.at(date + 1, *end_parts) : end_at
+      end
+
+      def validate_range(input, start_parts, end_parts)
+        if @clock.minutes(start_parts) == @clock.minutes(end_parts)
+          raise TimeFormatError, "Time range #{input} starts and ends at the same time."
+        end
+
+        validate_overnight(input, start_parts, end_parts)
+      end
+
+      # "9-5" almost always means 9am-5pm, but reads literally as 09:00 to
+      # 05:00 the next morning — a 20-hour window nobody asked for. So is
+      # "9a-5", where the am/pm is there but on the wrong side to help.
+      #
+      # Only guessed readings are checked, and only past 12 hours, which is
+      # what separates the mistake from the intent. An overnight shift written
+      # with a pm start ("9p-5", "10p-2") can only come out 12 hours or less;
+      # a dropped meridiem ("9-5", "9a-5", "10-5a") can only come out longer.
+      def validate_overnight(input, start_parts, end_parts)
+        return unless guessed?(start_parts, end_parts)
+
+        span = overnight_minutes(start_parts, end_parts)
+        return if span.nil? || span <= MAX_GUESSED_OVERNIGHT_MINUTES
+
+        raise TimeFormatError,
+              "Time range #{input} reads as crossing midnight and spans #{format_span(span)}. " \
+              'Add am/pm to both sides (9a-5p), use 24-hour times (9:00-17:00), ' \
+              'or --start/--end for a multi-day window.'
+      end
+
+      # True when a side's reading had to be guessed.
+      #
+      # A leftover ambiguous side is not enough on its own: in "20:00-6" the
+      # 24-hour start settles the whole range, so "6" is 6am and was not
+      # guessed. Without such an anchor, any side still bare after
+      # `infer_meridiems` was read as 24-hour for want of anything better —
+      # either because no meridiem was given at all ("9-5"), or because
+      # borrowing the one that was given would have inverted the range
+      # ("9a-5", where 5am precedes 9am).
+      def guessed?(start_parts, end_parts)
+        return false if @clock.twenty_four_hour?(start_parts) || @clock.twenty_four_hour?(end_parts)
+
+        @clock.ambiguous?(start_parts) || @clock.ambiguous?(end_parts)
+      end
+
+      # Wall-clock minutes from start to end across midnight, or nil when the
+      # window stays on one date.
+      #
+      # Deliberately not `end_at - start_at`: elapsed seconds stretch or shrink
+      # by an hour across a DST boundary, so the same text would report a
+      # different span depending on the date it happened to land on.
+      def overnight_minutes(start_parts, end_parts)
+        start_minutes = @clock.minutes(start_parts)
+        end_minutes = @clock.minutes(end_parts)
+        return nil if end_minutes > start_minutes
+
+        TimeParser::MINUTES_PER_DAY - start_minutes + end_minutes
+      end
+
+      # Whole hours read better, but rounding them would report a 12h01m window
+      # as "12 hours" against a 12-hour limit.
+      def format_span(minutes)
+        hours, mins = minutes.divmod(60)
+        mins.zero? ? "#{hours} hours" : format('%<h>dh%<m>02dm', h: hours, m: mins)
+      end
+    end
+  end
+end

data/lib/slk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Slk
-  VERSION = '0.5.0'
+  VERSION = '0.7.0'
 end