slk 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54edc7e40c9bcf891e2d2727c4cf50c4f43de73a70051465da12f3a97bc5282b
-  data.tar.gz: 40bbb5862b982c4e0d87d2a47c18b91a2f0070cac9fe7ad15a68e109114bf977
+  metadata.gz: 139ba582e24a6b92cd79493c0000a1479fbeb4ce59c90d883d0bbb603e8ff4c7
+  data.tar.gz: 81bdd74fc8a1d9b44480272098f78744297b3bd2b42b39dbc25c7f1fdb891c2f
 SHA512:
-  metadata.gz: 96abfcac2a271dccbce0a7b8068d23cf70d62ff68466e2a915fd67474aa9a3b6f648dce14ebaa87718c069993886a309c86490ab865a060586789bf8f8775752
-  data.tar.gz: ece446478a9dfda1dec3fa5dad6feff79c5f7be24e89f9835d61a0f3684e3d7839a94c673859ac5678a1f0f0c8675d31a9673493e744efcdd67433acda1f8fda
+  metadata.gz: f79c404a79de6d32c77e85226b92b65322ff159ae610201d3514abc66fc9f8497a30c29da802b81e0ed2f36cdb3bc805835eee0e85f744f0f323d2620391c483
+  data.tar.gz: 6fff7a3b9b11762d179ccd2d22e5a0e4a6e395f52bd4fe89810cb045fed144c989026c07928179efdcd35e8ac3c3c991dab8f90344042cd0475adc8fc1007d7e

data/CHANGELOG.md

@@ -7,6 +7,58 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.6.0] - 2026-04-27
+
+### Added
+
+- **`slk who [target]`** — compact teems-style profile card for self or any user
+  - Targets: positional arg accepts `Uxxx`, display name, real name, or email; defaults to self
+  - `--full` expands into Contact / People / About me sections matching the Slack web profile
+  - `--json` emits the full Profile struct for piping
+  - `--refresh` bypasses both the per-run memo and the on-disk meta cache
+  - `--all` prints every match in turn; `--pick N` picks the Nth match non-interactively
+  - Multi-match disambiguation: prints a numbered list on stderr and prompts on a TTY; non-TTY contexts raise instead of silently picking
+  - Renders Slack Connect external users with a stripped layout (`external — <home workspace>`)
+  - Marks deactivated accounts with a bold `deactivated account` tag (and `deactivated: true` in JSON)
+  - Type-aware custom field rendering: `link` fields use OSC 8 hyperlinks with their `alt` label, `date` fields show "Jun 17, 2024 (1y 10mo ago)", `user` fields resolve one level (name + pronouns + title)
+- **`slk org [target]`** — walks the supervisor chain upward from the target
+  - `--depth N` caps traversal (default 5); cycle-safe via seen-set
+  - Indented tree with `└─ ├─ │` glyphs; `← you` marker on whichever node is the authenticated user
+- New `Api::Team` wrapper for `team.info` and `team.profile.get`, plus `Api::Users#profile_for(user_id, include_labels:)`
+- `Services::ProfileResolver`, `ProfileBuilder`, `UserMatcher`, `UserPicker`, `WhoTargetResolver`, `MetaCache` services backing the new commands
+- Hidden `slk debug profile <uid>` subcommand for inspecting raw profile/info/schema responses
+
+### Changed
+
+- `ApiError` now carries a typed `code` symbol (`:user_not_found`, `:ratelimited`, `:network_error`, `:unauthorized`, `:http_error`, `:invalid_json`, `:missing_scope`); `ApiClient` populates it on every raise
+- `ProfileResolver` only swallows `:user_not_found` from `users.profile.get` (Slack Connect fallback to `users.info`); other API errors propagate so callers can surface them
+- CI matrix now uses `bundler-cache` and runs `bundle exec rake test`; new `coverage` job enforces a 95/95 line/branch SimpleCov threshold
+- Pinned `parallel < 2.0` in dev/test bundle to keep Ruby 3.2 compatible with current rubocop
+
+### Fixed
+
+- `slk org` no longer mislabels the wrong node with `← you` when invoked against a teammate — the marker now compares each node against the authenticated user id
+
+## [0.5.0] - 2026-04-13
+
+### Added
+
+- **`--fetch-attachments` flag** - Download message files and attachment images to local cache
+  - Downloads Slack files (authed) and public attachment images (Giphy, Tenor, etc.)
+  - Cached to `~/.cache/slk/files/{workspace}/` with skip-on-rerun
+  - Shows copyable local file paths in output: `[File: /path/to/file.png]`
+  - Works with `messages`, `thread`, and `--threads` inline replies
+  - Summary line when files are present: `9 files not downloaded. Use --fetch-attachments to download.`
+  - Follows up to 3 redirect hops with relative URL resolution
+
+### Changed
+
+- Added `rubocop` as a dev dependency for linting
+
+### Fixed
+
+- **`thread` command** - Extracted `resolve_and_display_thread` to fix rubocop complexity warnings
+
 ## [0.4.2] - 2026-03-01
 
 ### Added
@@ -131,6 +183,7 @@ Initial release of the Ruby rewrite. Pure Ruby, no external dependencies.
   - Pure Ruby stdlib - no gem dependencies
   - Ruby 3.2+ with modern features (Data.define, pattern matching)
 
+[0.5.0]: https://github.com/ericboehs/slk/releases/tag/v0.5.0
 [0.4.2]: https://github.com/ericboehs/slk/releases/tag/v0.4.2
 [0.4.0]: https://github.com/ericboehs/slk/releases/tag/v0.4.0
 [0.3.0]: https://github.com/ericboehs/slk/releases/tag/v0.3.0

data/lib/slk/api/team.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Slk
+  module Api
+    # Wrapper for Slack team.* API endpoints
+    class Team
+      def initialize(api_client, workspace)
+        @api = api_client
+        @workspace = workspace
+      end
+
+      def info(team_id = nil)
+        params = team_id ? { team: team_id } : {}
+        @api.post_form(@workspace, 'team.info', params)
+      end
+
+      def profile_schema(visibility: nil)
+        params = {}
+        params[:visibility] = visibility if visibility
+        @api.post_form(@workspace, 'team.profile.get', params)
+      end
+    end
+  end
+end

data/lib/slk/api/users.rb

@@ -49,6 +49,10 @@ module Slk
         }
       end
 
+      def get_presence_for(user_id)
+        @api.post_form(@workspace, 'users.getPresence', { user: user_id })
+      end
+
       def set_presence(presence) # rubocop:disable Naming/AccessorMethodName
         @api.post(@workspace, 'users.setPresence', { presence: presence })
       end
@@ -63,6 +67,12 @@ module Slk
         @api.post_form(@workspace, 'users.info', { user: user_id })
       end
 
+      def profile_for(user_id, include_labels: true)
+        params = { user: user_id }
+        params[:include_labels] = true if include_labels
+        @api.post_form(@workspace, 'users.profile.get', params)
+      end
+
       def get_prefs # rubocop:disable Naming/AccessorMethodName
         @api.post(@workspace, 'users.prefs.get')
       end

data/lib/slk/cli.rb

@@ -20,7 +20,10 @@ module Slk
       'cache' => Commands::Cache,
       'emoji' => Commands::Emoji,
       'config' => Commands::Config,
-      'help' => Commands::Help
+      'help' => Commands::Help,
+      'debug' => Commands::Debug,
+      'who' => Commands::Who,
+      'org' => Commands::Org
     }.freeze
 
     def initialize(argv, output: nil)
@@ -140,6 +143,11 @@ module Slk
       runner.api_client.on_request = lambda { |method, count|
         output.debug("[API ##{count}] #{method}")
       }
+      runner.api_client.on_response = lambda { |method, code, headers|
+        next unless code == 'rate-wait'
+
+        output.warn("Rate limited on #{method}; sleeping #{headers['sleep_seconds']}s and retrying...")
+      }
     end
 
     def setup_very_verbose_logging(runner, output)

data/lib/slk/commands/debug.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Slk
+  module Commands
+    # Hidden command for development spikes.
+    # Dumps raw JSON from Slack endpoints to validate xoxc compatibility
+    # and field shapes before building higher-level features.
+    #
+    # Not registered in `slk help`.
+    class Debug < Base
+      def execute
+        result = validate_options
+        return result if result
+
+        dispatch_action
+      rescue ApiError => e
+        error("API error: #{e.message}")
+        1
+      end
+
+      def dispatch_action
+        case positional_args
+        in ['profile', user] then dump_profile(user)
+        in ['profile'] then dump_profile(nil)
+        in ['team'] then dump_team
+        in ['schema'] then dump_schema
+        else unknown_action
+        end
+      end
+
+      private
+
+      def dump_profile(user_input)
+        workspace = runner.workspace(@options[:workspace])
+        user_id = resolve_user_id(workspace, user_input)
+        users_api = runner.users_api(workspace.name)
+        out = {
+          'users.profile.get' => users_api.profile_for(user_id),
+          'users.info' => users_api.info(user_id),
+          'team.profile.get' => runner.team_api(workspace.name).profile_schema
+        }
+        output.puts(JSON.pretty_generate(out))
+        0
+      end
+
+      def dump_team
+        workspace = runner.workspace(@options[:workspace])
+        output.puts(JSON.pretty_generate(runner.team_api(workspace.name).info))
+        0
+      end
+
+      def dump_schema
+        workspace = runner.workspace(@options[:workspace])
+        output.puts(JSON.pretty_generate(runner.team_api(workspace.name).profile_schema))
+        0
+      end
+
+      def resolve_user_id(workspace, user_input)
+        return self_user_id(workspace) if user_input.nil? || user_input == 'me'
+        return user_input if user_input.match?(/\A[UW][A-Z0-9]+\z/)
+
+        id = lookup_for(workspace).find_id_by_name(user_input.delete_prefix('@'))
+        raise ApiError, "Could not resolve user: #{user_input}" unless id
+
+        id
+      end
+
+      def lookup_for(workspace)
+        Services::UserLookup.new(
+          cache_store: cache_store,
+          workspace: workspace,
+          api_client: api_client,
+          on_debug: ->(msg) { output.debug(msg) }
+        )
+      end
+
+      def self_user_id(workspace)
+        client = Api::Client.new(api_client, workspace)
+        response = client.auth_test
+        response['user_id']
+      end
+
+      def unknown_action
+        error("Unknown debug action: #{positional_args.first.inspect}")
+        error('Valid actions: profile [user], team, schema')
+        1
+      end
+
+      protected
+
+      def help_text
+        <<~HELP
+          slk debug <action> [args]
+
+          Hidden development command — dumps raw API responses for spike validation.
+
+          ACTIONS
+            profile [user]   Dump users.profile.get + users.info + team.profile.get
+            team             Dump team.info
+            schema           Dump team.profile.get
+
+          USER
+            (none) | me      Self
+            @handle | name   Resolved via user cache
+            Uxxx             Raw user ID
+        HELP
+      end
+    end
+  end
+end

data/lib/slk/commands/org.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Slk
+  module Commands
+    # Walk the Slack org chart by following Supervisor custom profile fields.
+    # Examples:
+    #   slk org                        # self, supervisors up to depth 3
+    #   slk org @alex                  # alex's chain
+    #   slk org Uxxx --depth 5
+    #   slk org --down                 # reports (best-effort, requires reindex for completeness)
+    class Org < Base
+      DEFAULT_DEPTH = 5
+
+      def execute
+        result = validate_options
+        return result if result
+
+        run
+      rescue ApiError => e
+        error("API error: #{e.message}")
+        1
+      end
+
+      protected
+
+      def handle_option(arg, args, _remaining)
+        case arg
+        when '--up' then @options[:direction] = :up
+        when '--down' then @options[:direction] = :down
+        when '--depth' then @options[:depth] = args.shift.to_i
+        else return super
+        end
+        true
+      end
+
+      def help_text
+        <<~HELP
+          slk org [target]
+
+          Walk the Slack org chart by Supervisor field.
+
+          OPTIONS
+            --up               Walk supervisors upward (default)
+            --down             Show direct reports (best-effort, see note)
+            --depth N          Levels to walk (default #{DEFAULT_DEPTH})
+
+          NOTES
+            --down currently scans cached profiles only. Run `slk who` on a
+            user to seed their profile in cache; full crawl support is TODO.
+        HELP
+      end
+
+      private
+
+      def run
+        workspace = runner.workspace(@options[:workspace])
+        resolver = runner.profile_resolver(workspace.name, refresh: @options[:refresh])
+        user_id = resolve_user_id(workspace)
+        target = resolver.resolve(user_id)
+        @self_user_id = self_user_id(workspace)
+
+        case @options[:direction] || :up
+        when :up then render_up(resolver, target)
+        when :down then render_down(target)
+        end
+        0
+      end
+
+      def render_up(resolver, target)
+        chain = resolver.resolve_chain_up(target.user_id, depth: @options[:depth] || DEFAULT_DEPTH)
+        if chain.empty?
+          info("No supervisor on #{target.best_name}'s profile.")
+          return
+        end
+
+        chain.reverse_each.with_index do |profile, depth|
+          render_node(profile, depth, you: profile.user_id == @self_user_id)
+        end
+        render_node(target, chain.size, you: target.user_id == @self_user_id)
+      end
+
+      def render_down(target)
+        warn('slk org --down is best-effort against cached profiles only.')
+        warn('Run `slk who <user>` to seed their profile, or wait for `slk org reindex` (TODO).')
+        info("Direct reports for #{target.best_name}: lookup not yet wired (Phase 4).")
+      end
+
+      def render_node(profile, depth, you: false)
+        prefix = depth.zero? ? '' : "#{'  ' * depth}└─ "
+        marker = you ? output.bold(' ← you') : ''
+        title = profile.title.to_s.empty? ? '' : " — #{output.gray(profile.title)}"
+        output.puts("#{prefix}#{profile.best_name}#{title}#{marker}")
+      end
+
+      def resolve_user_id(workspace)
+        target = positional_args.first
+        return self_user_id(workspace) if target.nil? || target == 'me'
+        return target if target.match?(/\A[UW][A-Z0-9]+\z/)
+
+        Services::UserLookup.new(
+          cache_store: cache_store,
+          workspace: workspace,
+          api_client: api_client,
+          on_debug: ->(msg) { output.debug(msg) }
+        ).find_id_by_name(target.delete_prefix('@')) ||
+          (raise ApiError, "Could not resolve user: #{target}")
+      end
+
+      def self_user_id(workspace)
+        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/commands/who.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Slk
+  module Commands
+    # Display a Slack user profile (teems-style compact card by default).
+    # Examples:
+    #   slk who                  # self
+    #   slk who @alex
+    #   slk who alice
+    #   slk who Uxxx --full
+    #   slk who --json
+    class Who < Base
+      def execute
+        result = validate_options
+        return result if result
+
+        run
+      rescue ApiError => e
+        error("API error: #{e.message}")
+        1
+      end
+
+      protected
+
+      def handle_option(arg, args, _remaining)
+        case arg
+        when '--full' then @options[:full] = true
+        when '--no-cache', '--refresh' then @options[:refresh] = true
+        when '--all' then @options[:all] = true
+        when '--pick' then @options[:pick] = parse_pick(args.shift)
+        else return super
+        end
+        true
+      end
+
+      def help_text
+        <<~HELP
+          slk who [target]
+
+          Show a Slack user profile.
+
+          TARGET
+            (none)           Self
+            @handle | name   Resolved via user cache
+            Uxxx             Raw user ID
+
+          OPTIONS
+            --full           Section-grouped layout (Contact, People, About me)
+            --json           Raw JSON output
+            --refresh        Bypass cache
+            --all            Render every match (skips the disambiguation prompt)
+            --pick N         Auto-select match N when a name resolves to multiple
+        HELP
+      end
+
+      private
+
+      def parse_pick(value)
+        Integer(value)
+      rescue ArgumentError, TypeError
+        raise ApiError, "--pick expects an integer (got #{value.inspect})"
+      end
+
+      def run
+        workspace = runner.workspace(@options[:workspace])
+        profiles = resolve_profiles(workspace)
+        return output_json_profiles(profiles) if @options[:json]
+
+        render_profiles(profiles)
+        0
+      end
+
+      def resolve_profiles(workspace)
+        resolver = Services::WhoTargetResolver.new(
+          workspace: workspace, cache_store: cache_store,
+          api_client: api_client, output: output, options: @options
+        )
+        resolver.resolve(positional_args.first).map { |id| load_profile(workspace, id) }
+      end
+
+      def load_profile(workspace, user_id)
+        runner.profile_resolver(workspace.name, refresh: @options[:refresh])
+              .resolve_with_people(user_id)
+      end
+
+      def render_profiles(profiles)
+        profiles.each_with_index do |profile, idx|
+          output.puts(output.gray('—' * 40)) if idx.positive?
+          render(profile)
+        end
+      end
+
+      def render(profile)
+        formatter = Formatters::ProfileFormatter.new(
+          output: output, emoji_replacer: runner.emoji_replacer
+        )
+        @options[:full] ? formatter.full(profile) : formatter.compact(profile)
+      end
+
+      def output_json_profiles(profiles)
+        payload = profiles.map { |p| profile_payload(p) }
+        output_json(profiles.size == 1 ? payload.first : payload)
+        0
+      end
+
+      def profile_payload(profile)
+        profile.to_h.merge(
+          custom_fields: profile.visible_fields.map(&:to_h),
+          sections: profile.sections,
+          resolved_users: profile.resolved_users.transform_values(&:to_h)
+        )
+      end
+    end
+  end
+end

data/lib/slk/formatters/output.rb

@@ -18,6 +18,8 @@ module Slk
 
       attr_reader :verbose, :quiet
 
+      def color? = @color
+
       def initialize(io: $stdout, err: $stderr, color: nil, verbose: false, quiet: false)
         @io = io
         @err = err

data/lib/slk/formatters/profile_field_renderer.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Slk
+  module Formatters
+    # Renders ProfileField values to display strings (date with relative
+    # phrasing, link with alt text, type:user dereferenced via resolved_users).
+    class ProfileFieldRenderer
+      def initialize(output:)
+        @output = output
+        @hyperlinks = output.respond_to?(:color?) && output.color?
+      end
+
+      def render(field, profile)
+        case field.type
+        when 'date' then format_date(field.value)
+        when 'link' then format_link(field)
+        when 'user' then format_user_list(field, profile)
+        else format_text(field.value)
+        end
+      end
+
+      # Slack stores some text fields (notably free-text profile blocks) as
+      # rich_text JSON blocks. Detect and flatten to plain text.
+      def format_text(value)
+        text = value.to_s
+        return text unless text.start_with?('[{') && text.include?('rich_text')
+
+        flatten_rich_text(JSON.parse(text))
+      rescue JSON::ParserError
+        text
+      end
+
+      def flatten_rich_text(blocks)
+        Array(blocks).flat_map { |block| extract_text_from_block(block) }.join
+      end
+
+      def extract_text_from_block(block)
+        return [block.to_s] unless block.is_a?(Hash)
+
+        return [block['text'].to_s] if block['type'] == 'text'
+        return [block['name'] ? ":#{block['name']}:" : ''] if block['type'] == 'emoji'
+
+        Array(block['elements']).flat_map { |el| extract_text_from_block(el) }
+      end
+
+      def render_user_reference(user_id, profile)
+        ref = profile.resolved_users[user_id]
+        return user_id unless ref
+
+        suffix = ref.title.to_s.empty? ? '' : " — #{ref.title}"
+        pronouns = ref.pronouns.to_s.empty? ? '' : " #{@output.gray("(#{ref.pronouns})")}"
+        "#{ref.best_name}#{pronouns}#{suffix}"
+      end
+
+      private
+
+      def format_user_list(field, profile)
+        field.user_ids.map { |uid| render_user_reference(uid, profile) }.join(', ')
+      end
+
+      def format_date(value)
+        date = parse_date(value) or return value
+        relative = relative_phrase(date, Date.today)
+        formatted = date.strftime('%b %-d, %Y')
+        relative ? "#{formatted} (#{relative})" : formatted
+      end
+
+      def parse_date(value)
+        Date.parse(value.to_s)
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      def relative_phrase(then_date, now_date)
+        return nil if then_date >= now_date
+
+        years, months = years_months_between(then_date, now_date)
+        parts = []
+        parts << "#{years}y" if years.positive?
+        parts << "#{months}mo" if months.positive?
+        parts.empty? ? nil : "#{parts.join(' ')} ago"
+      end
+
+      def years_months_between(then_date, now_date)
+        months = ((now_date.year - then_date.year) * 12) + (now_date.month - then_date.month)
+        months -= 1 if now_date.day < then_date.day
+        [months / 12, months % 12]
+      end
+
+      def format_link(field)
+        url = field.value.to_s
+        label = field.alt.to_s.empty? ? url : field.alt
+        return url if label == url
+        return "#{label} (#{shorten_url(url)})" unless @hyperlinks
+
+        # OSC 8 hyperlink — clickable in iTerm2, Ghostty, Wezterm, Kitty, Vte.
+        "\e]8;;#{url}\a#{label}\e]8;;\a"
+      end
+
+      def shorten_url(url)
+        URI.parse(url).host || url
+      rescue URI::InvalidURIError
+        url
+      end
+    end
+  end
+end