slk 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09f740d5f0c6a9290031f4e94edff1bb118c85c80df51ccc4ef98b1dea6800a2'
-  data.tar.gz: 298d8188fd6bf43a07c8672523d9df253eff44dfe9481a0801d01062b161c8fd
+  metadata.gz: fd09692101d4658e57208d39e81d770e6dc36d2218088194ef55ad5fad0adbd0
+  data.tar.gz: 88e03a0be601536ffb3fd8f1b986900f8f57144b03a52ec5fa24b0b5dbdfbc57
 SHA512:
-  metadata.gz: dca5ad190d8155a4312bbafc39def037d1dfc9401170a58cc9adc2f22d6bbb4645efc7bcfd383e2be5d29b31c4f794da518f182df62182c47445fe3deec5d625
-  data.tar.gz: cba53cbbf73ed98c220bc984150792bd44e832992be70e62e62d425e2f0a6885f1414a1fe027d1d07ad449c1bef374f12aa2cc12814fda4cfe5bde9844df9f46
+  metadata.gz: 399ca26d5d030704ad553e579fab75376db1578e0814f1ad8a9c2e4115c44e32c8173263fb39c8839eb7a0014ca1758d4e1aaa33b8d65353ba64e6fe83fa8efe
+  data.tar.gz: 64bfbe31c44af1961f43cd7f027bd352847af05434b957bbceb03e26c8bdf820ee805c1fb67d2adac80e18e7ddc286fd643572a17695209db1e3e7826c358baa

data/CHANGELOG.md

@@ -5,6 +5,62 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.4.0] - 2026-01-30
+
+### Added
+
+- **Windows Support** - slk now runs on Windows
+  - Uses `%APPDATA%` and `%LOCALAPPDATA%` for config/cache directories
+  - Cross-platform command detection with `Open3.capture3`
+  - Proper NTFS permission handling (skips `chmod` on Windows)
+  - New `Support::Platform` module for OS-specific behavior
+  - CI testing on Windows (Ruby 3.2, 3.3, 3.4, 4.0)
+
+### Changed
+
+- New `UserLookup` service consolidates duplicate user name resolution logic
+- Removed ~65 lines of duplicated code from `MentionReplacer` and `MessageFormatter`
+
+## [0.3.0] - 2026-01-16
+
+### Added
+
+- `-vv`/`--very-verbose` flag for detailed API debugging with timing and response bodies
+- SSH key validation and token migration when keys change
+- Public key validation (ensures it matches private key)
+- `config unset` command for removing configuration values
+- CI infrastructure with GitHub Actions (Ruby 3.2-4.0, macOS, Ubuntu)
+
+### Changed
+
+- Improved error handling throughout with comprehensive tests
+- Better SSH key error messages with public key prompting
+- Cache user lookups to reduce API calls
+- Improved rate limit error messages
+
+### Fixed
+
+- Test output no longer leaks to stdout
+- All rubocop offenses resolved
+
+## [0.2.0] - 2025-01-15
+
+### Added
+
+- `--workspace-emoji` flag for messages command to display custom workspace emoji as inline images (experimental, requires iTerm2/WezTerm/Mintty)
+- JSON output now includes resolved user and channel names for `messages`, `activity`, and `unread` commands
+
+### Changed
+
+- Config/cache directories renamed from `slack-cli` to `slk`
+- Repository renamed from `slack-cli` to `slk`
+
+### Fixed
+
+- `error()` helper now returns exit code 1 for proper shell exit status
+
 ## [0.1.0] - 2025-01-14
 
 Initial release of the Ruby rewrite. Pure Ruby, no external dependencies.
@@ -43,4 +99,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.1.0]: https://github.com/ericboehs/slack-cli/releases/tag/v0.1.0
+[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
+[0.2.0]: https://github.com/ericboehs/slk/releases/tag/v0.2.0
+[0.1.0]: https://github.com/ericboehs/slk/releases/tag/v0.1.0

data/README.md

@@ -12,6 +12,22 @@ gem install slk
 
 Requires Ruby 3.2+.
 
+### Windows
+
+```powershell
+# Install Ruby (if needed) via RubyInstaller or Chocolatey
+winget install RubyInstallerTeam.Ruby.3.3
+# or: choco install ruby
+
+# Install slk
+gem install slk
+
+# (Optional) Install age for encrypted token storage
+choco install age.portable
+```
+
+Configuration is stored in `%APPDATA%\slk\` on Windows.
+
 ## Setup
 
 Run the setup wizard:
@@ -56,10 +72,10 @@ slk dnd off               # Disable DND
 ### Messages
 
 ```bash
-slk messages #general           # Read channel messages
+slk messages general            # Read channel messages
 slk messages @username          # Read DM with user
-slk messages #general -n 50     # Show 50 messages
-slk messages #general --json    # Output as JSON
+slk messages general -n 50      # Show 50 messages
+slk messages general --json     # Output as JSON
 ```
 
 ### Activity
@@ -86,7 +102,7 @@ Use `--show-messages` (or `-m`) to preview the actual message content for each a
 ```bash
 slk unread                # Show unread counts
 slk unread clear          # Mark all as read
-slk unread clear #general # Mark channel as read
+slk unread clear general  # Mark channel as read
 ```
 
 ### Catchup (Interactive Triage)
@@ -151,17 +167,17 @@ Optionally encrypt your tokens with [age](https://github.com/FiloSottile/age) us
 slk config set ssh_key ~/.ssh/id_ed25519
 ```
 
-Tokens will be stored encrypted in `~/.config/slack-cli/tokens.age`.
+Tokens will be stored encrypted in `~/.config/slk/tokens.age`.
 
 ## Configuration
 
-Files are stored in XDG-compliant locations:
+Files are stored in XDG-compliant locations (or `%APPDATA%`/`%LOCALAPPDATA%` on Windows):
 
-- **Config**: `~/.config/slack-cli/`
+- **Config**: `~/.config/slk/` (Windows: `%APPDATA%\slk\`)
   - `config.json` - Settings
   - `tokens.json` or `tokens.age` - Workspace tokens
   - `presets.json` - Status presets
-- **Cache**: `~/.cache/slack-cli/`
+- **Cache**: `~/.cache/slk/` (Windows: `%LOCALAPPDATA%\slk\`)
   - `users-{workspace}.json` - User cache
   - `channels-{workspace}.json` - Channel cache
 
@@ -169,21 +185,23 @@ Files are stored in XDG-compliant locations:
 
 ```bash
 # Clone the repo
-git clone https://github.com/ericboehs/slack-cli.git
-cd slack-cli
+git clone https://github.com/ericboehs/slk.git
+cd slk
 
 # Run from source
 ruby -Ilib bin/slk --version
 
 # Run tests
 rake test
+```
 
-# Build gem
-gem build slk.gemspec
+### Releasing
 
-# Install locally
-gem install ./slk-0.1.0.gem
-```
+1. Update version in `lib/slk/version.rb`
+2. Update `CHANGELOG.md` (move Unreleased to new version, add date)
+3. Commit: `git commit -am "Release vX.Y.Z"`
+4. Release to RubyGems: `rake release`
+5. Create GitHub Release: `gh release create vX.Y.Z --generate-notes`
 
 ## License
 

data/bin/ci

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+# Run the full CI suite (tests + linting)
+set -e
+
+cd "$(dirname "$0")/.."
+
+echo "==> Running tests..."
+rake test
+
+echo ""
+echo "==> Running rubocop..."
+rubocop
+
+echo ""
+echo "==> All checks passed!"

data/bin/coverage

@@ -0,0 +1,225 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'nokogiri'
+end
+
+# Path to the SimpleCov HTML report
+coverage_file = File.join(Dir.pwd, 'coverage', 'index.html')
+
+unless File.exist?(coverage_file)
+  puts "No coverage report found at #{coverage_file}"
+  puts 'Run tests first: COVERAGE=1 bundle exec rake test'
+  exit 1
+end
+
+# Parse the HTML file
+doc = Nokogiri::HTML(File.read(coverage_file))
+
+# Extract overall line coverage
+line_percent = doc.css('.covered_percent span').first&.text&.strip
+total_lines = doc.css('.t-line-summary b').first&.text&.strip
+covered_lines = doc.css('.t-line-summary .green b').first&.text&.strip
+missed_lines = doc.css('.t-line-summary .red b').first&.text&.strip
+
+# Extract overall branch coverage (first t-branch-summary is the overall stats)
+overall_branch_summary = doc.css('.t-branch-summary').first
+if overall_branch_summary
+  branch_percent = overall_branch_summary.css('span').last.text.strip.gsub(/[()]/, '')
+  branch_summary_spans = overall_branch_summary.css('span b')
+  overall_total_branches = branch_summary_spans[0]&.text&.strip
+  overall_covered_branches = branch_summary_spans[1]&.text&.strip
+  overall_missed_branches = branch_summary_spans[2]&.text&.strip
+else
+  # No branch coverage available
+  branch_percent = nil
+  overall_total_branches = nil
+  overall_covered_branches = nil
+  overall_missed_branches = nil
+end
+
+# Extract timestamp
+timestamp = doc.css('.timestamp .timeago').first&.attr('title')
+
+puts '## SimpleCov Coverage Report'
+puts "Generated: #{timestamp}"
+puts ''
+
+puts "### Line Coverage: #{line_percent}"
+puts "  #{covered_lines}/#{total_lines} lines covered"
+puts "  #{missed_lines} lines missed"
+puts ''
+
+if branch_percent
+  puts "### Branch Coverage: #{branch_percent}"
+  puts "  #{overall_covered_branches}/#{overall_total_branches} branches covered"
+  puts "  #{overall_missed_branches} branches missed"
+  puts ''
+end
+
+# Show file-by-file breakdown if there are missed lines or branches
+if missed_lines.to_i.positive? || overall_missed_branches&.to_i&.positive?
+  # First, collect all files with missing coverage
+  files_with_issues = []
+  files_shown = Set.new
+
+  doc.css('tbody .t-file').each do |row|
+    file_name = row.css('.t-file__name a').first&.text&.strip
+    line_coverage = row.css('.t-file__coverage').first&.text&.strip
+    branch_coverage = row.css('.t-file__branch-coverage').first&.text&.strip
+
+    # Only include files that aren't 100% covered and haven't been seen yet
+    should_skip = files_shown.include?(file_name) ||
+                  (line_coverage == '100.00 %' && (!branch_coverage || branch_coverage == '100.00 %'))
+    next if should_skip
+
+    files_shown.add(file_name)
+    files_with_issues << row
+  end
+
+  total_files_with_issues = files_with_issues.length
+  files_to_show = files_with_issues.take(50)
+
+  puts '### Files with missing coverage:'
+  puts ''
+  if total_files_with_issues > 50
+    puts "Showing top 50 of #{total_files_with_issues} files with missing coverage:"
+    puts ''
+  end
+
+  # rubocop:disable Metrics/BlockLength
+  files_to_show.each do |row|
+    file_name = row.css('.t-file__name a').first&.text&.strip
+    line_coverage = row.css('.t-file__coverage').first&.text&.strip
+    branch_coverage = row.css('.t-file__branch-coverage').first&.text&.strip
+    file_link = row.css('.t-file__name a').first&.attr('href')
+
+    # Extract detailed line information for this file
+    missed_lines = []
+    missed_branches = []
+    total_file_lines = 0
+    covered_file_lines = 0
+
+    if file_link
+      file_id = file_link.gsub('#', '')
+      file_section = doc.css("##{file_id}")
+
+      if file_section.any?
+        # Get the actual counts from SimpleCov's summary
+        line_summary = file_section.css('.t-line-summary')
+        if line_summary.any? # rubocop:disable Metrics/BlockNesting
+          summary_text = line_summary.text
+          # Extract numbers from text like "13 relevant lines. 12 lines covered and 1 lines missed."
+          total_file_lines = Regexp.last_match(1).to_i if summary_text.match(/(\d+)\s+relevant\s+lines/) # rubocop:disable Metrics/BlockNesting
+          covered_file_lines = Regexp.last_match(1).to_i if summary_text.match(/(\d+)\s+lines\s+covered/) # rubocop:disable Metrics/BlockNesting
+        end
+
+        # Find missed lines and branches
+        file_section.css('li').each do |line_item|
+          line_number = line_item.attr('data-linenumber')
+          line_class = line_item.attr('class')
+
+          if line_class&.include?('missed') && !line_class.include?('missed-branch') # rubocop:disable Metrics/BlockNesting
+            missed_lines << line_number
+          elsif line_class&.include?('missed-branch') # rubocop:disable Metrics/BlockNesting
+            missed_branches << line_number
+          end
+        end
+      end
+    end
+
+    # Format the line ranges more clearly
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def format_line_ranges(lines)
+      return '' if lines.empty?
+
+      ranges = []
+      current_range = [lines.first.to_i]
+
+      lines.map(&:to_i).sort[1..]&.each do |line|
+        if line == current_range.last + 1
+          current_range << line
+        else
+          ranges << format_range(current_range)
+          current_range = [line]
+        end
+      end
+      ranges << format_range(current_range)
+
+      "L#{ranges.join(', L')}"
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    def format_range(range)
+      if range.length == 1
+        range.first.to_s
+      else
+        "#{range.first}-#{range.last}"
+      end
+    end
+
+    # Get branch counts from the file section
+    covered_branches = 0
+    total_branches = 0
+
+    if file_link
+      file_id = file_link.gsub('#', '')
+      file_section = doc.css("##{file_id}")
+      branch_summary = file_section.css('.t-branch-summary')
+
+      if branch_summary.any?
+        branch_spans = branch_summary.css('span b')
+        total_branches = branch_spans[0]&.text.to_i
+        covered_branches = branch_spans[1]&.text.to_i
+      end
+    end
+
+    branch_display = branch_coverage ? "Branch: #{branch_coverage}" : 'Branch: N/A'
+    puts "  #{file_name} (Line: #{line_coverage}, #{branch_display}):"
+
+    line_info = "Lines: #{covered_file_lines}/#{total_file_lines}"
+    line_info += " (missed: #{format_line_ranges(missed_lines)})" unless missed_lines.empty?
+    puts "         #{line_info}"
+
+    if total_branches.positive?
+      branch_info = "Branches: #{covered_branches}/#{total_branches}"
+      branch_info += " (missed: #{format_line_ranges(missed_branches)})" unless missed_branches.empty?
+      puts "         #{branch_info}"
+    end
+
+    puts ''
+  end
+  # rubocop:enable Metrics/BlockLength
+end
+
+# Write to GitHub Actions job summary if available
+if ENV['GITHUB_STEP_SUMMARY']
+  File.open(ENV['GITHUB_STEP_SUMMARY'], 'a') do |f|
+    f.puts ''
+    f.puts '## Test Coverage Report'
+    f.puts ''
+    f.puts "**Line Coverage:** #{line_percent} (#{covered_lines}/#{total_lines} lines)"
+    f.puts ''
+
+    if branch_percent
+      f.puts "**Branch Coverage:** #{branch_percent} (#{overall_covered_branches}/#{overall_total_branches} branches)"
+      f.puts ''
+    end
+
+    # Add visual indicators
+    line_pct_value = line_percent.gsub('%', '').to_f
+    branch_pct_value = branch_percent&.gsub('%', '')&.to_f
+
+    if line_pct_value >= 95 && (!branch_pct_value || branch_pct_value >= 95)
+      f.puts 'Coverage meets quality thresholds'
+    elsif line_pct_value >= 80 && (!branch_pct_value || branch_pct_value >= 80)
+      f.puts 'Coverage is acceptable but could be improved'
+    else
+      f.puts 'Coverage is below recommended thresholds'
+    end
+  end
+end

data/bin/slk

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
-require "slack_cli"
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'slk'
 
-exit SlackCli::CLI.new(ARGV).run
+exit Slk::CLI.new(ARGV).run

data/bin/test

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# Run the test suite
+set -e
+
+cd "$(dirname "$0")/.."
+
+rake test "$@"

data/lib/{slack_cli → slk}/api/activity.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Api
+    # Wrapper for the Slack activity.feed API endpoint
     class Activity
       def initialize(api_client, workspace)
         @api = api_client
@@ -9,20 +10,18 @@ module SlackCli
       end
 
       def feed(limit: 50, types: nil, cursor: nil, mode: 'priority_reads_and_unreads_v1')
-        params = {
-          mode: mode,
-          limit: limit.to_s,
-          archive_only: 'false',
-          snooze_only: 'false',
-          unread_only: 'false',
-          priority_only: 'false',
-          is_activity_inbox: 'false'
-        }
+        params = build_feed_params(mode, limit)
         params[:types] = types if types
         params[:cursor] = cursor if cursor
-
         @api.post_form(@workspace, 'activity.feed', params)
       end
+
+      private
+
+      def build_feed_params(mode, limit)
+        { mode: mode, limit: limit.to_s, archive_only: 'false', snooze_only: 'false',
+          unread_only: 'false', priority_only: 'false', is_activity_inbox: 'false' }
+      end
     end
   end
 end

data/lib/{slack_cli → slk}/api/bots.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Api
+    # Wrapper for Slack bots.info API endpoint
     class Bots
       def initialize(api_client, workspace, on_debug: nil)
         @api = api_client
@@ -13,8 +14,8 @@ module SlackCli
       # @param bot_id [String] Bot ID starting with "B"
       # @return [Hash, nil] Bot info hash or nil if not found
       def info(bot_id)
-        response = @api.post_form(@workspace, "bots.info", { bot: bot_id })
-        response["bot"] if response["ok"]
+        response = @api.post_form(@workspace, 'bots.info', { bot: bot_id })
+        response['bot'] if response['ok']
       rescue ApiError => e
         @on_debug&.call("Bot lookup failed for #{bot_id}: #{e.message}")
         nil
@@ -25,7 +26,7 @@ module SlackCli
       # @return [String, nil] Bot name or nil if not found
       def get_name(bot_id)
         bot = info(bot_id)
-        bot&.dig("name")
+        bot&.dig('name')
       end
     end
   end

data/lib/slk/api/client.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Slk
+  module Api
+    # Wrapper for Slack client.counts and auth.test API endpoints
+    class Client
+      def initialize(api_client, workspace)
+        @api = api_client
+        @workspace = workspace
+      end
+
+      def counts
+        @api.post(@workspace, 'client.counts')
+      end
+
+      def auth_test
+        @api.post(@workspace, 'auth.test')
+      end
+
+      def team_id
+        @team_id ||= auth_test['team_id']
+      end
+
+      def unread_channels
+        response = counts
+        channels = response['channels'] || []
+
+        channels.select { |ch| (ch['mention_count'] || 0).positive? || ch['has_unreads'] }
+      end
+
+      def unread_dms
+        response = counts
+        dms = response['ims'] || []
+        mpims = response['mpims'] || []
+
+        (dms + mpims).select { |dm| (dm['mention_count'] || 0).positive? || dm['has_unreads'] }
+      end
+
+      def total_unread_count
+        response = counts
+        sum_mentions(response, 'channels') + sum_mentions(response, 'ims') + sum_mentions(response, 'mpims')
+      end
+
+      private
+
+      def sum_mentions(response, key)
+        (response[key] || []).sum { |item| item['mention_count'] || 0 }
+      end
+    end
+  end
+end

data/lib/{slack_cli → slk}/api/conversations.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Api
+    # Wrapper for Slack conversations.* API endpoints
     class Conversations
       def initialize(api_client, workspace)
         @api = api_client
         @workspace = workspace
       end
 
-      def list(cursor: nil, limit: 1000, types: "public_channel,private_channel")
+      def list(cursor: nil, limit: 1000, types: 'public_channel,private_channel')
         params = { limit: limit, types: types }
         params[:cursor] = cursor if cursor
-        @api.post(@workspace, "conversations.list", params)
+        @api.post(@workspace, 'conversations.list', params)
       end
 
       def history(channel:, limit: 20, cursor: nil, oldest: nil, latest: nil)
@@ -19,33 +20,33 @@ module SlackCli
         params[:cursor] = cursor if cursor
         params[:oldest] = oldest if oldest
         params[:latest] = latest if latest
-        @api.post(@workspace, "conversations.history", params)
+        @api.post(@workspace, 'conversations.history', params)
       end
 
-      def replies(channel:, ts:, limit: 100, cursor: nil)
-        params = { channel: channel, ts: ts, limit: limit }
+      def replies(channel:, timestamp:, limit: 100, cursor: nil)
+        params = { channel: channel, ts: timestamp, limit: limit }
         params[:cursor] = cursor if cursor
         # Use form encoding - some workspaces (Enterprise Grid) require it
-        @api.post_form(@workspace, "conversations.replies", params)
+        @api.post_form(@workspace, 'conversations.replies', params)
       end
 
       def open(users:)
-        user_list = Array(users).join(",")
-        @api.post(@workspace, "conversations.open", { users: user_list })
+        user_list = Array(users).join(',')
+        @api.post(@workspace, 'conversations.open', { users: user_list })
       end
 
-      def mark(channel:, ts:)
-        @api.post(@workspace, "conversations.mark", { channel: channel, ts: ts })
+      def mark(channel:, timestamp:)
+        @api.post(@workspace, 'conversations.mark', { channel: channel, ts: timestamp })
       end
 
       def info(channel:)
-        @api.post_form(@workspace, "conversations.info", { channel: channel })
+        @api.post_form(@workspace, 'conversations.info', { channel: channel })
       end
 
       def members(channel:, cursor: nil, limit: 100)
         params = { channel: channel, limit: limit }
         params[:cursor] = cursor if cursor
-        @api.post(@workspace, "conversations.members", params)
+        @api.post(@workspace, 'conversations.members', params)
       end
     end
   end

data/lib/slk/api/dnd.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Slk
+  module Api
+    # Wrapper for Slack dnd.* (Do Not Disturb) API endpoints
+    class Dnd
+      def initialize(api_client, workspace)
+        @api = api_client
+        @workspace = workspace
+      end
+
+      def info
+        @api.post(@workspace, 'dnd.info')
+      end
+
+      def set_snooze(duration) # rubocop:disable Naming/AccessorMethodName
+        minutes = duration.to_minutes
+        @api.post(@workspace, 'dnd.setSnooze', { num_minutes: minutes })
+      end
+
+      def end_snooze
+        @api.post(@workspace, 'dnd.endSnooze')
+      end
+
+      def snoozing?
+        info['snooze_enabled'] == true
+      end
+
+      def snooze_remaining
+        data = info
+        return nil unless data['snooze_enabled']
+
+        endtime = data['snooze_endtime']
+        return nil unless endtime
+
+        remaining = endtime - Time.now.to_i
+        remaining.positive? ? Models::Duration.new(seconds: remaining) : nil
+      end
+    end
+  end
+end