wassup 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be426163a7aa15bbb7b9ce4c02cce9facffa0cc44bc5e50cb1de5ef770eb63e0
-  data.tar.gz: d47f33e03030ca9e43c30105ad308a6b48a358603bc0a9681d3b52a49f99d47f
+  metadata.gz: 23906c1fdf983d063b8201f142a2cdbc5f44b87c9ec5a7f846287bda1d99223c
+  data.tar.gz: d3d9223c00be833ba713f3d89c7c1bab2a443b6e0aa838d10372e61f81ba80c7
 SHA512:
-  metadata.gz: c963ab844d3d509e092d6d937a032dacb497079f980367c372b1b48de80c37696933190eb2e9f878a9a841ce9ab496645c04eb00e303147ad08331e70a867fd3
-  data.tar.gz: 6f0e4dd7432790afb71be30f20b377966185a61a9b079d73acca4a341825677911f435eb02adba390daffd348134807fdf67a4986f0c776bad4d6ed3058fded0
+  metadata.gz: 9cc7cfa1ebcb3c6a489e58e8f4f8f427ac07ae3bff4dc9eed2ac24a032da7833b75040e46deb7de8da3791b32f7611c17ae812ff2dc799e63827d285150bdb32
+  data.tar.gz: 4d18e7c3511a01f655ca75d6a457d313848e6e1ef45069a5a7c202c4a446656573a1ae156267c489d671034e9fbc9a4c765dd1ba7c49acea0da35731d85d6715

data/.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    
+    strategy:
+      matrix:
+        ruby-version: ['3.0', '3.1', '3.2', '3.3']
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    
+    - name: Set up Ruby ${{ matrix.ruby-version }}
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+    
+    - name: Run tests
+      run: bundle exec rspec

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    wassup (0.3.2)
+    wassup (0.4.1)
       curses
       rest-client
 
@@ -9,7 +9,7 @@ GEM
   remote: https://rubygems.org/
   specs:
     colorize (0.8.1)
-    curses (1.4.4)
+    curses (1.5.3)
     diff-lcs (1.4.4)
     domain_name (0.5.20190701)
       unf (>= 0.0.5, < 1.0.0)
@@ -45,6 +45,8 @@ GEM
 
 PLATFORMS
   arm64-darwin-21
+  arm64-darwin-24
+  x86_64-linux
 
 DEPENDENCIES
   colorize

data/README.md

@@ -2,6 +2,7 @@
   <img height="200" alt="Wassup logo" src="https://user-images.githubusercontent.com/401294/145626927-7eb0fda5-c62a-47c8-9422-074b178fd8ef.png" />
 </h3>
 
+[![CI](https://github.com/joshdholtz/wassup/actions/workflows/ci.yml/badge.svg)](https://github.com/joshdholtz/wassup/actions/workflows/ci.yml)
 [![License](https://img.shields.io/badge/license-MIT-green.svg?style=flat)](https://github.com/fastlane/fastlane/blob/master/LICENSE)
 [![Gem](https://img.shields.io/gem/v/wassup.svg?style=flat)](https://rubygems.org/gems/wassup)
 

data/bin/wassup

@@ -4,13 +4,14 @@ require 'wassup'
 
 debug = ARGV.delete("--debug")
 path = ARGV[0] || 'Supfile'
+port = ARGV[1] || 0
 
-unless File.exists?(path)
+unless File.exist?(path)
   raise "Missing file: #{path}"
 end
 
 if debug
   Wassup::App.debug(path: path)
 else
-  Wassup::App.start(path: path)
+  Wassup::App.start(path: path, port: port.to_i)
 end

data/examples/github_api_demo.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/wassup/helpers/github'
+
+# Example demonstrating how to use the new GitHub API method
+# to replace manual RestClient requests with rate-limited API calls
+
+# Instead of manual RestClient calls like:
+# resp = RestClient::Request.execute(
+#   method: :get, 
+#   url: "https://api.github.com/repos/owner/repo/pulls/123", 
+#   user: ENV["WASSUP_GITHUB_USERNAME"],
+#   password: ENV["WASSUP_GITHUB_ACCESS_TOKEN"]
+# )
+# pr = JSON.parse(resp)
+
+# Use the new GitHub API method:
+org = "your-org"
+repo = "your-repo"
+pr_number = 123
+
+# Get PR data
+pr = Wassup::Helpers::GitHub.api(path: "/repos/#{org}/#{repo}/pulls/#{pr_number}")
+
+puts "PR: #{pr['title']}"
+puts "Draft: #{pr['draft']}"
+puts "Requested reviewers: #{pr['requested_reviewers'].size}"
+puts "Requested teams: #{pr['requested_teams'].size}"
+
+# Get PR reviews
+reviews = Wassup::Helpers::GitHub.api(path: "/repos/#{org}/#{repo}/pulls/#{pr_number}/reviews")
+
+# Filter out your own reviews
+reviews = reviews.select { |review| review["user"]["login"] != "your-username" }
+
+approved = reviews.count { |review| review["state"] == "APPROVED" }
+changes_requested = reviews.count { |review| review["state"] == "CHANGES_REQUESTED" }
+
+puts "Approved: #{approved}"
+puts "Changes requested: #{changes_requested}"
+
+# Get check runs for the PR's head commit
+head_sha = pr["head"]["sha"]
+check_runs = Wassup::Helpers::GitHub.api(path: "/repos/#{org}/#{repo}/commits/#{head_sha}/check-runs")
+
+puts "Check runs: #{check_runs['check_runs'].size}"
+
+# Get commit statuses
+statuses = Wassup::Helpers::GitHub.api(path: "/repos/#{org}/#{repo}/commits/#{head_sha}/statuses")
+
+puts "Statuses: #{statuses.size}"
+
+# Count different status types
+success_count = statuses.count { |status| status["state"] == "success" }
+failure_count = statuses.count { |status| status["state"] == "failure" }
+
+puts "Success: #{success_count}, Failures: #{failure_count}"
+
+# Example with query parameters
+# Get PRs with specific state
+open_prs = Wassup::Helpers::GitHub.api(
+  path: "/repos/#{org}/#{repo}/pulls", 
+  params: { state: "open", per_page: 10 }
+)
+
+puts "Open PRs: #{open_prs.size}"
+
+# Example with POST request (creating an issue comment)
+# comment_body = { body: "This is a test comment" }
+# new_comment = Wassup::Helpers::GitHub.api(
+#   path: "/repos/#{org}/#{repo}/issues/#{pr_number}/comments",
+#   method: :post,
+#   body: comment_body
+# )

data/examples/rate_limiter_demo.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+# Demo script to show how the rate limiter handles burst requests
+
+require_relative '../lib/wassup/helpers/github_rate_limiter'
+
+# Mock the RestClient for demo purposes
+class MockRestClient
+  def self.execute(**args)
+    # Simulate API response time
+    sleep(0.05)
+    
+    # Create a mock response with rate limit headers
+    response = OpenStruct.new(
+      body: '{"items": []}',
+      headers: {
+        x_ratelimit_remaining: rand(100..4999),
+        x_ratelimit_reset: (Time.now + 3600).to_i,
+        x_ratelimit_limit: 5000
+      }
+    )
+    
+    puts "Request processed: #{args[:url]} (remaining: #{response.headers[:x_ratelimit_remaining]})"
+    response.body
+  end
+end
+
+# Replace RestClient with our mock
+module RestClient
+  Request = MockRestClient
+end
+
+# Test burst handling
+puts "Testing Rate Limiter with Burst Requests"
+puts "=" * 50
+
+rate_limiter = Wassup::Helpers::GitHub::RateLimiter.instance
+
+# Send 20 requests simultaneously
+puts "\nSending 20 requests simultaneously..."
+start_time = Time.now
+
+threads = []
+20.times do |i|
+  threads << Thread.new do
+    begin
+      rate_limiter.execute_request(
+        method: :get,
+        url: "https://api.github.com/test/#{i}"
+      )
+      puts "Request #{i+1} completed"
+    rescue => e
+      puts "Request #{i+1} failed: #{e.message}"
+    end
+  end
+end
+
+# Wait for all requests to complete
+threads.each(&:join)
+
+end_time = Time.now
+puts "\nAll requests completed in #{(end_time - start_time).round(2)} seconds"
+
+# Show final status
+puts "\nFinal Rate Limiter Status:"
+puts rate_limiter.status
+
+# Cleanup
+rate_limiter.stop_worker

data/lib/wassup/app.rb

@@ -2,7 +2,7 @@ require 'curses'
 
 module Wassup
   class App
-    def self.start(path:)
+    def self.start(path:, port:)
       Curses.init_screen
       Curses.start_color
       Curses.curs_set(0) # Invisible cursor
@@ -17,7 +17,7 @@ module Wassup
       #Curses.init_pair(Curses::COLOR_BLUE,Curses::COLOR_BLUE,Curses::COLOR_BLACK) 
       #Curses.init_pair(Curses::COLOR_RED,Curses::COLOR_RED,Curses::COLOR_BLACK)
 
-      app = App.new(path: path)
+      app = App.new(path: path, port: port)
     end
 
     def self.debug(path:)
@@ -78,6 +78,7 @@ module Wassup
         content_block: pane_builder.content_block,
         selection_blocks: pane_builder.selection_blocks,
         selection_blocks_description: pane_builder.selection_blocks_description,
+        port: self.port,
         debug: debug
       )
       pane.focus_handler = @focus_handler
@@ -85,9 +86,11 @@ module Wassup
     end
 
     attr_accessor :panes
+    attr_accessor :port
     attr_accessor :debug
 
-    def initialize(path:, debug: false)
+    def initialize(path:, port: nil, debug: false)
+      @port = port
       @hidden_pane = nil
       @help_pane = nil
       @focused_pane = nil
@@ -169,9 +172,15 @@ module Wassup
               pane.refresh()
             end
             @redraw_panes = false
+            # Use doupdate for more efficient screen updates when multiple panes are updated
+            Curses.doupdate if @panes.size > 1
           else
             @help_pane.refresh()
           end
+          
+          # Add throttling to prevent busy-waiting and reduce battery drain
+          # 10ms delay limits to ~100 FPS while maintaining responsiveness
+          sleep(0.01)
         end
       ensure
         Curses.close_screen
@@ -244,8 +253,16 @@ module Wassup
           end 
         end
 
+        # Ensure main panes are properly drawn before opening help
+        @panes.each do |id, pane|
+          pane.redraw()
+          pane.refresh()
+        end
+        
         # Maybe find a way to add some a second border or an clear border to add more space to show its floating
-        @help_pane = Pane.new(0.5, 0.5, 0.25, 0.25, title: "Help", highlight: false, focus_number: nil, interval: 100, show_refresh: false, content_block: content_block, selection_blocks: nil, selection_blocks_description: nil)
+        @help_pane = Pane.new(0.5, 0.5, 0.25, 0.25, title: "Help", highlight: false, focus_number: nil, interval: 1000, show_refresh: false, content_block: content_block, selection_blocks: nil, selection_blocks_description: nil)
+        # Force initial refresh to show content immediately
+        @help_pane.refresh(force: true)
       else
         @help_pane.close
         @help_pane = nil 

data/lib/wassup/helpers/github.rb

@@ -3,6 +3,7 @@ module Wassup
     module GitHub
       require 'json'
       require 'rest-client'
+      require_relative 'github_rate_limiter'
 
       # https://docs.github.com/en/search-github/searching-on-github/searching-issues-and-pull-requests
       def self.issues(org:, repo:nil, q: nil)
@@ -22,12 +23,9 @@ module Wassup
 
         items = []
 
-        resp = RestClient::Request.execute(
+        resp = RateLimiter.execute_request(
           method: :get, 
-          url: "https://api.github.com/search/issues?q=#{q}", 
-          user: ENV["WASSUP_GITHUB_USERNAME"],
-          password: ENV["WASSUP_GITHUB_ACCESS_TOKEN"],
-          headers: { "Accept": "application/vnd.github.v3+json", "Content-Type": "application/json" },
+          url: "https://api.github.com/search/issues?q=#{q}"
         )
         partial_items = JSON.parse(resp)["items"]
         items += partial_items
@@ -36,11 +34,9 @@ module Wassup
       end
 
       def self.repos(org:)
-        resp = RestClient::Request.execute(
+        resp = RateLimiter.execute_request(
           method: :get, 
-          url: "https://api.github.com/orgs/#{org}/repos", 
-          user: ENV["WASSUP_GITHUB_USERNAME"],
-          password: ENV["WASSUP_GITHUB_ACCESS_TOKEN"]
+          url: "https://api.github.com/orgs/#{org}/repos"
         )
         return JSON.parse(resp)
       end
@@ -57,11 +53,9 @@ module Wassup
         end
         
         return repos.map do |repo|
-          resp = RestClient::Request.execute(
+          resp = RateLimiter.execute_request(
             method: :get, 
-            url: "https://api.github.com/repos/#{repo.org}/#{repo.repo}/pulls?per_page=100", 
-            user: ENV["WASSUP_GITHUB_USERNAME"],
-            password: ENV["WASSUP_GITHUB_ACCESS_TOKEN"]
+            url: "https://api.github.com/repos/#{repo.org}/#{repo.repo}/pulls?per_page=100"
           )
 
           JSON.parse(resp)
@@ -69,15 +63,46 @@ module Wassup
       end
 
       def self.releases(org:, repo:)
-        resp = RestClient::Request.execute(
+        resp = RateLimiter.execute_request(
           method: :get, 
-          url: "https://api.github.com/repos/#{org}/#{repo}/releases", 
-          user: ENV["WASSUP_GITHUB_USERNAME"],
-          password: ENV["WASSUP_GITHUB_ACCESS_TOKEN"]
+          url: "https://api.github.com/repos/#{org}/#{repo}/releases"
         )
 
         return JSON.parse(resp)
       end
+
+      # Generic GitHub API method for any endpoint
+      def self.api(path:, method: :get, params: {}, body: nil)
+        # Handle full URLs or relative paths
+        if path.start_with?('http')
+          url = path
+        else
+          # Ensure path starts with /
+          path = "/#{path}" unless path.start_with?('/')
+          url = "https://api.github.com#{path}"
+        end
+        
+        # Add query parameters if provided
+        if params.any?
+          query_string = params.map { |k, v| "#{k}=#{v}" }.join('&')
+          url += "?#{query_string}"
+        end
+        
+        # Prepare request options
+        options = {}
+        if body
+          options[:payload] = body.is_a?(String) ? body : body.to_json
+        end
+        
+        # Make the request using the rate limiter
+        resp = RateLimiter.execute_request(
+          method: method,
+          url: url,
+          **options
+        )
+        
+        return JSON.parse(resp)
+      end
     end
   end
 end

data/lib/wassup/helpers/github_rate_limiter.rb

@@ -0,0 +1,380 @@
+module Wassup
+  module Helpers
+    module GitHub
+      class RateLimiter
+        require 'json'
+        require 'rest-client'
+        require 'thread'
+        require 'timeout'
+
+        attr_reader :remaining, :reset_at, :limit, :queue_size
+
+        def initialize
+          @mutex = Mutex.new
+          @queue = []
+          @remaining = nil
+          @reset_at = nil
+          @limit = nil
+          @search_remaining = nil
+          @search_reset_at = nil
+          @search_limit = nil
+          @last_request_time = nil
+          @worker_threads = []
+          @running = false
+          @max_queue_size = 20
+          @max_concurrent_requests = 5
+          @min_delay_between_requests = 1 # seconds
+          @min_delay_between_search_requests = 5 # seconds (12 requests/minute to avoid abuse detection)
+          @last_search_request_time = nil
+          @current_requests = []
+          @last_completed_request = nil
+          @last_error = nil
+        end
+
+        def start_worker
+          return if @running
+          
+          @running = true
+          @max_concurrent_requests.times do |i|
+            @worker_threads << Thread.new do
+              process_queue
+            end
+          end
+        end
+
+        def stop_worker
+          @running = false
+          @worker_threads.each(&:join)
+          @worker_threads.clear
+        end
+
+        def execute_request(method:, url:, **options)
+          future = RequestFuture.new
+          
+          @mutex.synchronize do
+            # Reject requests if queue is too large
+            if @queue.size >= @max_queue_size
+              future.set_error(StandardError.new("Rate limiter queue is full (#{@max_queue_size} requests). Please try again later."))
+              return future.get
+            end
+            
+            @queue << {
+              future: future,
+              method: method,
+              url: url,
+              options: options,
+              queued_at: Time.now
+            }
+          end
+
+          start_worker
+          
+          # Add timeout to prevent hanging
+          begin
+            Timeout.timeout(120) do
+              future.get
+            end
+          rescue Timeout::Error
+            queue_size = @mutex.synchronize { @queue.size }
+            raise StandardError.new("GitHub API request timed out after 120 seconds: #{method} #{url} (queue size: #{queue_size})")
+          end
+        end
+
+        def queue_size
+          @mutex.synchronize { @queue.size }
+        end
+
+        def status
+          @mutex.synchronize do
+            next_search_available = nil
+            if @last_search_request_time
+              next_search_time = @last_search_request_time + @min_delay_between_search_requests
+              next_search_available = [(next_search_time - Time.now).to_i, 0].max
+            end
+            
+            {
+              remaining: @remaining,
+              reset_at: @reset_at,
+              limit: @limit,
+              search_remaining: @search_remaining,
+              search_reset_at: @search_reset_at,
+              search_limit: @search_limit,
+              next_search_available: next_search_available,
+              queue_size: @queue.size,
+              running: @running,
+              worker_threads: @worker_threads.size,
+              current_requests: @current_requests.dup,
+              last_completed: @last_completed_request,
+              last_error: @last_error
+            }
+          end
+        end
+
+        private
+
+        def process_queue
+          while @running
+            request = nil
+            
+            @mutex.synchronize do
+              request = @queue.shift
+            end
+
+            if request
+              process_request(request)
+            else
+              sleep(0.1)
+            end
+          end
+        end
+
+        def process_request(request)
+          queue_time = Time.now - request[:queued_at]
+          request_start = Time.now
+          
+          # Track current request
+          @mutex.synchronize do
+            @current_requests << "#{request[:method]} #{request[:url]}"
+          end
+          
+          wait_if_needed
+          
+          begin
+            response = make_request(
+              method: request[:method],
+              url: request[:url],
+              **request[:options]
+            )
+            
+            request_time = Time.now - request_start
+            
+            update_rate_limit_from_response(response)
+            request[:future].set_result(response)
+            
+            # Track completed request
+            @mutex.synchronize do
+              @current_requests.delete("#{request[:method]} #{request[:url]}")
+              @last_completed_request = "#{request[:method]} #{request[:url]} (#{request_time.round(2)}s)"
+            end
+            
+            # Add minimum delay between requests to prevent overwhelming the API
+            sleep(@min_delay_between_requests)
+            
+          rescue RestClient::TooManyRequests => e
+            @mutex.synchronize do
+              @current_requests.delete("#{request[:method]} #{request[:url]}")
+              @last_error = "Rate limit exceeded: #{request[:method]} #{request[:url]}"
+            end
+            handle_rate_limit_exceeded(request, e)
+          rescue RestClient::Forbidden => e
+            @mutex.synchronize do
+              @current_requests.delete("#{request[:method]} #{request[:url]}")
+              @last_error = "Forbidden: #{request[:method]} #{request[:url]}"
+            end
+            handle_forbidden_error(request, e)
+          rescue => e
+            @mutex.synchronize do
+              @current_requests.delete("#{request[:method]} #{request[:url]}")
+              @last_error = "Error: #{e.message}"
+            end
+            request[:future].set_error(e)
+          end
+        end
+
+        def wait_if_needed
+          current_time = Time.now.to_i
+          
+          # Check if this is a search request and enforce minimum delay
+          if @last_search_request_time
+            time_since_last_search = Time.now - @last_search_request_time
+            if time_since_last_search < @min_delay_between_search_requests
+              sleep_time = @min_delay_between_search_requests - time_since_last_search
+              sleep(sleep_time) if sleep_time > 0
+            end
+          end
+          
+          # Check search API rate limit
+          if @search_remaining && @search_reset_at
+            if @search_remaining == 0 && current_time < @search_reset_at
+              sleep_time = @search_reset_at - current_time + 1
+              sleep(sleep_time) if sleep_time > 0
+              return
+            end
+            
+            # If search API is low, add extra delay
+            if @search_remaining < 5
+              sleep(3)
+              return
+            end
+          end
+          
+          # Check regular API rate limit
+          if @remaining && @reset_at
+            if @remaining == 0 && current_time < @reset_at
+              sleep_time = @reset_at - current_time + 1
+              sleep(sleep_time) if sleep_time > 0
+              return
+            end
+
+            # Calculate dynamic delay based on remaining requests and time
+            delay = calculate_dynamic_delay
+            sleep(delay) if delay > 0
+          end
+        end
+
+        def calculate_dynamic_delay
+          return 0 unless @remaining && @reset_at
+
+          current_time = Time.now.to_i
+          time_until_reset = [@reset_at - current_time, 0].max
+          
+          # If we have plenty of requests remaining, no delay needed
+          return 0 if @remaining > 50
+          
+          # If we're getting low on requests, add a small delay
+          if @remaining < 10
+            return 2.0
+          elsif @remaining < 25
+            return 1.0
+          else
+            return 0.5
+          end
+        end
+
+        def handle_rate_limit_exceeded(request, error)
+          # Check if the error response has retry-after header
+          retry_after = error.response&.headers&.[](:retry_after)
+          
+          if retry_after
+            sleep_time = retry_after.to_i + 1
+          elsif @reset_at
+            # Fallback to reset time or exponential backoff
+            sleep_time = [@reset_at - Time.now.to_i + 1, 60].max
+          else
+            # Default fallback when no reset time is available
+            sleep_time = 60
+          end
+
+          sleep(sleep_time)
+          
+          # Retry the request
+          @mutex.synchronize do
+            @queue.unshift(request)
+          end
+        end
+
+        def handle_forbidden_error(request, error)
+          # Check if this is rate limiting disguised as 403 (GitHub API inconsistency)
+          response_body = error.response&.body
+          if response_body&.include?("rate limit") || response_body&.include?("abuse")
+            # Treat as rate limit and retry
+            handle_rate_limit_exceeded(request, error)
+          else
+            # Genuine authentication/authorization error - don't retry
+            request[:future].set_error(error)
+          end
+        end
+
+        def make_request(method:, url:, **options)
+          @last_request_time = Time.now
+          
+          # Track search requests
+          if url.include?('/search/')
+            @last_search_request_time = Time.now
+          end
+
+          # Set default headers for GitHub API
+          headers = {
+            "Accept" => "application/vnd.github.v3+json",
+            "Content-Type" => "application/json"
+          }.merge(options[:headers] || {})
+
+          # Add authentication
+          auth_options = {
+            user: ENV["WASSUP_GITHUB_USERNAME"],
+            password: ENV["WASSUP_GITHUB_ACCESS_TOKEN"]
+          }
+
+          RestClient::Request.execute(
+            method: method,
+            url: url,
+            headers: headers,
+            **auth_options,
+            **options.except(:headers)
+          )
+        end
+
+        def update_rate_limit_from_response(response)
+          # Handle case where response is a string (from tests)
+          return unless response.respond_to?(:headers)
+          
+          headers = response.headers
+          
+          # Check for search API rate limit headers first
+          if headers[:x_ratelimit_resource] == 'search'
+            @search_remaining = headers[:x_ratelimit_remaining]&.to_i
+            @search_reset_at = headers[:x_ratelimit_reset]&.to_i
+            @search_limit = headers[:x_ratelimit_limit]&.to_i
+          else
+            # Regular API rate limit headers
+            @remaining = headers[:x_ratelimit_remaining]&.to_i
+            @reset_at = headers[:x_ratelimit_reset]&.to_i
+            @limit = headers[:x_ratelimit_limit]&.to_i
+          end
+        end
+
+        # Singleton instance
+        @instance = nil
+        @instance_mutex = Mutex.new
+
+        def self.instance
+          @instance_mutex.synchronize do
+            @instance ||= new
+          end
+        end
+
+        def self.execute_request(**args)
+          instance.execute_request(**args)
+        end
+
+        def self.status
+          instance.status
+        end
+      end
+
+      class RequestFuture
+        def initialize
+          @mutex = Mutex.new
+          @condition = ConditionVariable.new
+          @result = nil
+          @error = nil
+          @completed = false
+        end
+
+        def set_result(result)
+          @mutex.synchronize do
+            @result = result
+            @completed = true
+            @condition.signal
+          end
+        end
+
+        def set_error(error)
+          @mutex.synchronize do
+            @error = error
+            @completed = true
+            @condition.signal
+          end
+        end
+
+        def get
+          @mutex.synchronize do
+            @condition.wait(@mutex) until @completed
+            raise @error if @error
+            @result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wassup/pane.rb

@@ -1,5 +1,6 @@
 require 'curses'
 
+require 'socket'
 require 'time'
 
 module Wassup
@@ -42,6 +43,11 @@ module Wassup
 
     attr_accessor :win_height, :win_width, :win_top, :win_left
 
+    attr_accessor :port
+
+    # Performance optimization attributes
+    attr_accessor :last_content_hash, :last_highlighted_line, :last_focused_state, :parsed_lines_cache
+
 		class Content
 			class Row
 				attr_accessor :display
@@ -68,7 +74,9 @@ module Wassup
 			end
 		end
 
-    def initialize(height, width, top, left, title: nil, description: nil, alert_level: nil, highlight: true, focus_number: nil, interval:, show_refresh:, content_block:, selection_blocks:, selection_blocks_description:, debug: false)
+    def initialize(height, width, top, left, title: nil, description: nil, alert_level: nil, highlight: true, focus_number: nil, interval:, show_refresh:, content_block:, selection_blocks:, selection_blocks_description:, port: nil, debug: false)
+
+      self.port = port
 
       if !debug
         self.win_height = Curses.lines * height	
@@ -92,6 +100,12 @@ module Wassup
       self.show_refresh = show_refresh
      
       self.selected_view_index = 0
+      
+      # Initialize performance optimization attributes
+      self.last_content_hash = nil
+      self.last_highlighted_line = nil
+      self.last_focused_state = nil
+      self.parsed_lines_cache = {}
 
       if !debug
         self.win.refresh
@@ -236,6 +250,8 @@ module Wassup
 
 					self.update_box
 					self.update_title
+
+          self.send_to_socket
         else
           # This shouldn't happen
           # TODO: also fix this
@@ -317,7 +333,7 @@ module Wassup
 
       self.last_refresh_char_at ||= Time.now
 
-      if Time.now - self.last_refresh_char_at >= 0.15
+      if Time.now - self.last_refresh_char_at >= 0.25
         self.win.setpos(0, 1)
         self.win.addstr(self.refresh_char)
         self.win.refresh
@@ -325,6 +341,31 @@ module Wassup
         self.last_refresh_char_at = Time.now
       end
     end
+
+    def send_to_socket
+      return if self.port.nil?
+      return if self.port.to_i == 0
+
+      data = {
+        title: self.title,
+        description: self.description,
+        alert_level: self.alert_level,
+        alert_count: self.alert_count
+      }
+
+      sock = TCPSocket.new('127.0.0.1', self.port)
+      sock.write(data.to_json)
+      sock.close
+    end
+
+    def alert_count
+      alert_count = 0
+      if self.contents
+        alert_count = self.contents.map { |c| c.data.size }.inject(0, :+)
+      end
+
+      return alert_count
+    end
       
     def update_title
       return unless self.should_box
@@ -343,10 +384,7 @@ module Wassup
 
       self.win.setpos(0, 3 + full_title.size)
       alert = ""
-      alert_count = 0
-      if self.contents
-        alert_count = self.contents.map { |c| c.data.size }.inject(0, :+)
-      end
+      alert_count = self.alert_count
       case self.alert_level
       when AlertLevel::HIGH
 			  self.win.attrset(Curses.color_pair(Wassup::Color::Pair::RED))
@@ -410,8 +448,59 @@ module Wassup
       self.subwin.refresh
     end
 
+    # Cache color parsing results to avoid redundant regex operations
+    def parse_line_colors(line)
+      return self.parsed_lines_cache[line] if self.parsed_lines_cache.key?(line)
+      
+      splits = line.split(/\[.*?\]/) # returns ["hey something", "other thing", "okay"]
+      scans = line.scan(/\[.*?\]/) #returns ["red", "white"]
+      scans = scans.map do |str|
+        if str.start_with?('[fg=')
+          str = str.gsub('[fg=', '').gsub(']','')
+          Wassup::Color.new(str)
+        else
+          str
+        end
+      end
+      
+      all_parts = splits.zip(scans).flatten.compact
+      
+      # Cache the result
+      self.parsed_lines_cache[line] = all_parts
+      
+      # Limit cache size to prevent memory bloat
+      if self.parsed_lines_cache.size > 1000
+        # Remove oldest entries (keep most recent 500)
+        self.parsed_lines_cache = self.parsed_lines_cache.to_a.last(500).to_h
+      end
+      
+      all_parts
+    end
+
     def virtual_reload
       return if self.data_lines.nil? || self.data_lines.empty?
+      
+      # Skip optimization for first-time loads or if optimization attributes aren't initialized
+      if self.last_content_hash.nil? || self.last_highlighted_line.nil? || self.last_focused_state.nil?
+        # Initialize on first run and force redraw
+        self.last_content_hash = self.data_lines.hash
+        self.last_highlighted_line = self.highlighted_line
+        self.last_focused_state = self.focused
+      else
+        # Check if content has changed to avoid unnecessary redraws
+        current_content_hash = self.data_lines.hash
+        highlight_changed = self.last_highlighted_line != self.highlighted_line
+        focus_changed = self.last_focused_state != self.focused
+        
+        if current_content_hash == self.last_content_hash && !highlight_changed && !focus_changed
+          return # No changes, skip redraw
+        end
+        
+        # Track what changed for next time
+        self.last_content_hash = current_content_hash
+        self.last_highlighted_line = self.highlighted_line
+        self.last_focused_state = self.focused
+      end
 
       # TODO: This errored out but might be because thread stuff???
       self.data_lines[self.top..(self.top+self.subwin.maxy-1)].each_with_index do |line, idx|
@@ -423,18 +512,8 @@ module Wassup
        
 				self.subwin.attrset(Curses.color_pair(Wassup::Color::Pair::NORMAL))
 
-				splits = line.split(/\[.*?\]/) # returns ["hey something", "other thing", "okay"]
-				scans = line.scan(/\[.*?\]/) #returns ["red", "white"]
-				scans = scans.map do |str|
-					if str.start_with?('[fg=')
-						str = str.gsub('[fg=', '').gsub(']','')
-						Wassup::Color.new(str)
-					else
-						str
-					end
-				end
-
-				all_parts = splits.zip(scans).flatten.compact
+				# Use cached color parsing instead of expensive regex operations
+				all_parts = parse_line_colors(line)
 		
 				char_count = 0
 

data/lib/wassup/version.rb

@@ -1,3 +1,3 @@
 module Wassup
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/mise.toml

@@ -0,0 +1,2 @@
+[tools]
+ruby = "3.2"

data/wassup.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.description   = %q{A scriptable terminal dashboard}
   spec.homepage      = "https://github.com/joshdholtz/wassup"
   spec.license       = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/joshdholtz/wassup"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wassup
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Josh Holtz
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-04 00:00:00.000000000 Z
+date: 2025-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: curses
@@ -47,6 +47,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".github/FUNDING.yml"
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
@@ -95,9 +96,11 @@ files:
 - docs/tsconfig.json
 - examples/basic/Supfile
 - examples/debug/Supfile
+- examples/github_api_demo.rb
 - examples/josh-fastlane/README.md
 - examples/josh-fastlane/Supfile
 - examples/josh-fastlane/demo.png
+- examples/rate_limiter_demo.rb
 - examples/simple/Supfile
 - examples/starter/Supfile
 - lib/wassup.rb
@@ -105,6 +108,7 @@ files:
 - lib/wassup/color.rb
 - lib/wassup/helpers/circleci.rb
 - lib/wassup/helpers/github.rb
+- lib/wassup/helpers/github_rate_limiter.rb
 - lib/wassup/helpers/netlify.rb
 - lib/wassup/helpers/shortcut.rb
 - lib/wassup/pane.rb
@@ -114,6 +118,7 @@ files:
 - lib/wassup/panes/netlify.rb
 - lib/wassup/panes/shortcut.rb
 - lib/wassup/version.rb
+- mise.toml
 - wassup.gemspec
 homepage: https://github.com/joshdholtz/wassup
 licenses:
@@ -129,14 +134,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: A scriptable terminal dashboard