cleaned up/simplified the code

exe/rat

···
 #!/usr/bin/env ruby
-# frozen_string_literal: true
 
-# rat – Ruby ATProto Tool
-#
-# Simple CLI for Bluesky AT Protocol using:
-# - Minisky  (XRPC client)
-# - Skyfall  (firehose / Jetstream streaming)
-# - DIDKit   (DID / handle resolution)
-#
-# Usage:
-#   rat fetch at://<did-or-handle>/<collection-nsid>/<rkey>
-#   rat stream <relay.host> [-j|--jetstream] [-r|--cursor CURSOR] \
-#                [-d|--did DID,...] [-c|--collection NSID,...]
-#   rat resolve <did-or-handle>
-#   rat help | --help
-#   rat version | --version
-
-require 'optparse'
+require 'didkit'
 require 'json'
+require 'minisky'
+require 'optparse'
+require 'skyfall'
 require 'time'
 require 'uri'
 
-require 'minisky'
-require 'skyfall'
-require 'didkit'   # defines DIDKit::DID and top-level DID alias
-
 VERSION = '0.0.1'
 
-DID_REGEX       = /\Adid:[a-z0-9]+:[a-zA-Z0-9.\-_:]+\z/
-DOMAIN_REGEX    = /\A[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+\z/i
-HOST_PORT_REGEX = /\A#{DOMAIN_REGEX.source}(?::\d+)?\z/i
+DID_REGEXP = /\Adid:[a-z]+:[a-zA-Z0-9.\-_]+\z/
+NSID_REGEXP = /\A[a-z0-9]+(\.[a-z0-9]+)+\z/
 
-def global_help
-  <<~HELP
-    rat #{VERSION}
+def print_help
+  puts <<~HELP
+    rat #{VERSION} 🦡
 
     Usage:
-      rat fetch at://<did-or-handle>/<collection-nsid>/<rkey>
-      rat stream <relay.host> [options]
-      rat resolve <did-or-handle>
-      rat help | --help
-      rat version | --version
+      rat fetch at://uri
+      rat stream <firehose-host> [options]
+      rat resolve <did>|<handle>
 
     Commands:
       fetch     Fetch a single record given its at:// URI
-      stream    Stream commit events from a relay / PDS firehose
-      resolve   Resolve a DID or @handle using DIDKit
+      stream    Stream events from a relay / PDS firehose
+      resolve   Resolve a DID or @handle
       help      Show this help
       version   Show version
 
     Stream options:
-      -j, --jetstream                  Use Skyfall::Jetstream (JSON)
-                                       (uses Jetstream wanted_dids / wanted_collections
-                                       when -d/-c are provided)
-      -r, --cursor CURSOR              Start from cursor (seq or time_us)
+      -j, --jetstream                  Use a Jetstream source instead of a CBOR firehose
+      -r, --cursor CURSOR              Start from a given cursor
       -d, --did DID[,DID...]           Filter only events from given DID(s)
                                        (can be passed multiple times)
       -c, --collection NSID[,NSID...]  Filter only events of given collection(s)
···
   HELP
 end
 
-def abort_with_help(message = nil)
-  warn "Error: #{message}" if message
-  warn
-  warn global_help
+def abort_with_error(message)
+  puts message
   exit 1
 end
 
-def valid_did?(s)
-  DID_REGEX.match?(s)
-end
-
-def valid_handle?(s)
-  DOMAIN_REGEX.match?(s)
-end
-
-def valid_nsid?(s)
-  # NSIDs look like domain names (reverse DNS), so reuse DOMAIN_REGEX
-  DOMAIN_REGEX.match?(s)
-end
-
-def validate_handle!(s, context: 'handle')
-  unless valid_handle?(s)
-    abort_with_help("#{s.inspect} doesn't look like a valid #{context}")
+def validate_did(did)
+  unless did =~ DID_REGEXP
+    abort_with_error "Error: #{did.inspect} is not a valid DID"
   end
-  s
 end
 
-def validate_did!(s)
-  unless valid_did?(s)
-    abort_with_help("#{s.inspect} doesn't look like a valid DID")
+def validate_nsid(collection)
+  unless collection =~ NSID_REGEXP
+    abort_with_error "Error: #{collection.inspect} is not a valid collection NSID"
   end
-  s
 end
 
-def validate_nsid!(nsid)
-  unless valid_nsid?(nsid)
-    abort_with_help("#{nsid.inspect} doesn't look like a valid collection NSID")
-  end
-  nsid
-end
-
-def parse_at_uri(str)
-  unless str.start_with?('at://')
-    abort_with_help("not an at:// URI: #{str.inspect}")
+def parse_at_uri(uri)
+  unless uri.start_with?('at://')
+    abort_with_error "Error: not an at:// URI: #{uri.inspect}"
   end
 
-  m = /\Aat:\/\/([^\/]+)\/([^\/]+)\/([^\/]+)\z/.match(str)
-  unless m
-    abort_with_help("invalid at:// URI: expected at://<repo>/<collection>/<rkey>")
+  unless uri =~ /\Aat:\/\/([^\/]+)\/([^\/]+)\/([^\/]+)\z/
+    abort_with_error "Error: invalid at:// URI: #{uri.inspect}"
   end
 
-  repo, collection, rkey = m.captures
-  [repo, collection, rkey]
+  [$1, $2, $3]
 end
 
-def resolve_repo_to_did_and_pds(repo_str)
-  if repo_str.start_with?('did:')
-    validate_did!(repo_str)
-    did_obj = DID.new(repo_str)
-  else
-    handle = repo_str.sub(/\A@/, '')
-    validate_handle!(handle, context: 'handle in at:// URI')
-    did_obj = DID.resolve_handle(handle)
-  end
+def run_fetch(args)
+  uri = args.shift
 
-  doc = did_obj.document
-  pds_host = doc.pds_host
-  unless pds_host && !pds_host.empty?
-    abort_with_help("DID document for #{did_obj} does not contain a pds_host")
+  if uri.nil?
+    abort_with_error "Usage: #{$PROGRAM_NAME} fetch <at://uri>"
   end
 
-  [did_obj.to_s, pds_host]
-rescue StandardError => e
-  warn "Error resolving repo #{repo_str.inspect}: #{e.class}: #{e.message}"
-  exit 1
-end
-
-def do_fetch(argv)
-  uri = argv.shift or abort_with_help("fetch requires an at:// URI")
-  unless argv.empty?
-    abort_with_help("unexpected extra arguments for fetch: #{argv.join(' ')}")
+  if !args.empty?
+    abort_with_error "Error: Unexpected arguments for fetch: #{args.join(' ')}"
   end
 
-  repo_str, collection, rkey = parse_at_uri(uri)
+  repo, collection, rkey = parse_at_uri(uri)
 
-  # basic validation of collection (NSID-ish)
-  validate_nsid!(collection)
-
-  did, pds_host = resolve_repo_to_did_and_pds(repo_str)
-
-  client = Minisky.new(pds_host, nil)
-  params = { repo: did, collection: collection, rkey: rkey }
+  begin
+    pds = DID.new(repo).document.pds_host
+    sky = Minisky.new(pds, nil)
 
-  begin
-    res = client.get_request('com.atproto.repo.getRecord', params)
+    response = sky.get_request('com.atproto.repo.getRecord', {
+      repo: repo, collection: collection, rkey: rkey
+    })
   rescue StandardError => e
-    warn "Error calling com.atproto.repo.getRecord: #{e.class}: #{e.message}"
-    exit 1
+    abort_with_error "Error loading record: #{e.class}: #{e.message}"
   end
 
-  value = res['value']
-  if value.nil?
-    warn "Warning: response did not contain a 'value' field"
-    puts JSON.pretty_generate(res)
-  else
-    puts JSON.pretty_generate(value)
-  end
+  puts JSON.pretty_generate(response['value'])
 end
 
-def do_resolve(argv)
-  target = argv.shift or abort_with_help("resolve requires a DID or handle")
-  unless argv.empty?
-    abort_with_help("unexpected extra arguments for resolve: #{argv.join(' ')}")
+def run_resolve(args)
+  target = args.shift
+
+  if target.nil?
+    abort_with_error "Usage: #{$PROGRAM_NAME} resolve <did>|<handle>"
   end
 
-  if target.start_with?('did:')
-    validate_did!(target)
-    begin
-      did_obj = DID.new(target)
-      doc = did_obj.document
-      json = doc.respond_to?(:json) ? doc.json : doc
-      puts did_obj.to_s
-      puts JSON.pretty_generate(json)
-    rescue StandardError => e
-      warn "Error resolving DID #{target.inspect}: #{e.class}: #{e.message}"
-      exit 1
-    end
-  else
-    handle = target.sub(/\A@/, '')
-    validate_handle!(handle)
-    begin
-      did_obj = DID.resolve_handle(handle)
-      doc = did_obj.document
-      json = doc.respond_to?(:json) ? doc.json : doc
-      puts did_obj.to_s
-      puts JSON.pretty_generate(json)
-    rescue StandardError => e
-      warn "Error resolving handle #{target.inspect}: #{e.class}: #{e.message}"
-      exit 1
-    end
+  if !args.empty?
+    abort_with_error "Error: Unexpected arguments for resolve: #{args.join(' ')}"
   end
-end
 
-def validate_relay_host!(host)
-  # Accept:
-  #   - bare hostname or hostname:port
-  #   - ws://host[:port]
-  #   - wss://host[:port]
-  if host =~ /\Aws:\/\//i || host =~ /\Awss:\/\//i
-    uri = URI(host)
-    if uri.path && uri.path != '' && uri.path != '/'
-      abort_with_help("relay URL must not contain a path: #{host.inspect}")
-    end
-    unless uri.host && DOMAIN_REGEX.match?(uri.host)
-      abort_with_help("invalid relay hostname in URL: #{host.inspect}")
-    end
-  else
-    unless HOST_PORT_REGEX.match?(host)
-      abort_with_help("invalid relay hostname: #{host.inspect}")
-    end
+  did = DID.resolve_handle(target)
+
+  if did.nil?
+    abort_with_error "Couldn't resolve #{target}"
   end
 
-  host
-rescue URI::InvalidURIError
-  abort_with_help("invalid relay URL: #{host.inspect}")
+  puts JSON.pretty_generate(did.document.json)
+rescue StandardError => e
+  abort_with_error "Error resolving #{target.inspect}: #{e.class}: #{e.message}"
 end
 
-def parse_stream_options(argv)
-  options = {
-    use_jetstream: false,
-    cursor:        nil,
-    dids:          [],
-    collections:   []
-  }
+def parse_stream_options(args)
+  options = {}
 
   parser = OptionParser.new do |opts|
-    opts.banner = "Usage: rat stream <relay.host> [options]"
+    opts.banner = "Usage: #{$PROGRAM_NAME} stream <relay.host> [options]"
 
-    opts.on('-j', '--jetstream', 'Use Skyfall::Jetstream (JSON)') do
-      options[:use_jetstream] = true
+    opts.on('-j', '--jetstream', 'Use a Jetstream source') do
+      options[:jetstream] = true
     end
 
-    opts.on('-rCURSOR', '--cursor=CURSOR', 'Start from cursor (seq or time_us)') do |cursor|
+    opts.on('-rCURSOR', '--cursor=CURSOR', 'Start from a given cursor') do |cursor|
       options[:cursor] = cursor
     end
 
-    opts.on('-dLIST', '--did=LIST',
-            'Filter only events from DID(s) (comma-separated or repeated)') do |list|
+    opts.on('-dLIST', '--did=LIST', 'Filter only events from given DID(s) (comma-separated or repeated)') do |list|
       items = list.split(',').map(&:strip).reject(&:empty?)
+
       if items.empty?
-        abort_with_help("empty argument to -d/--did")
+        abort_with_error "Error: empty argument to -d/--did"
       end
-      options[:dids].concat(items)
+
+      options[:dids] ||= []
+      options[:dids] += items
     end
 
-    opts.on('-cLIST', '--collection=LIST',
-            'Filter only events of given collection NSID(s)') do |list|
+    opts.on('-cLIST', '--collection=LIST', 'Filter only events of given collections') do |list|
       items = list.split(',').map(&:strip).reject(&:empty?)
+
       if items.empty?
-        abort_with_help("empty argument to -c/--collection")
+        abort_with_error "Error: empty argument to -c/--collection"
       end
-      options[:collections].concat(items)
+
+      options[:collections] ||= []
+      options[:collections] += items
     end
 
     opts.on('-h', '--help', 'Show stream-specific help') do
       puts opts
-      exit 0
+      exit
     end
   end
 
   remaining = []
+
   begin
-    parser.order!(argv) { |nonopt| remaining << nonopt }
+    parser.order!(args) { |other| remaining << other }
   rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
-    warn "Error: #{e.message}"
-    warn parser
+    puts "Error: #{e.message}"
+    puts parser
     exit 1
   end
 
   [options, remaining]
 end
 
-def do_stream(argv)
-  options, remaining = parse_stream_options(argv)
+def run_stream(args)
+  options, arguments = parse_stream_options(args)
+
+  service = arguments.shift
 
-  host = remaining.shift or abort_with_help("stream requires a relay hostname")
-  validate_relay_host!(host)
+  if service.nil?
+    abort_with_error "Usage: #{$PROGRAM_NAME} stream <firehose-host> [options]"
+  end
 
-  unless remaining.empty?
-    abort_with_help("unexpected extra arguments for stream: #{remaining.join(' ')}")
+  if !arguments.empty?
+    abort_with_error "Error: Unexpected arguments for stream: #{arguments.join(' ')}"
   end
 
-  # validate cursor (if given)
   if options[:cursor] && options[:cursor] !~ /\A\d+\z/
-    abort_with_help("cursor must be a decimal integer, got #{options[:cursor].inspect}")
+    abort_with_error "Error: cursor must be a decimal integer, got: #{options[:cursor].inspect}"
   end
 
-  # validate DIDs
-  options[:dids].each do |did|
-    validate_did!(did)
+  if options[:dids]
+    options[:dids].each { |did| validate_did(did) }
   end
 
-  # validate collections
-  options[:collections].each do |nsid|
-    validate_nsid!(nsid)
+  if options[:collections]
+    options[:collections].each { |collection| validate_nsid(collection) }
   end
 
-  # Build Skyfall client
-  if options[:use_jetstream]
+  if options[:jetstream]
     jet_opts = {}
     jet_opts[:cursor] = options[:cursor].to_i if options[:cursor]
 
-    # Pass filters through to Jetstream server-side
-    jet_opts[:wanted_dids] = options[:dids] unless options[:dids].empty?
-    jet_opts[:wanted_collections] = options[:collections] unless options[:collections].empty?
+    # pass DID/collection filters to Jetstream to filter events server-side
+    jet_opts[:wanted_dids] = options[:dids] if options[:dids]
+    jet_opts[:wanted_collections] = options[:collections] if options[:collections]
 
-    sky = Skyfall::Jetstream.new(host, jet_opts)
+    sky = Skyfall::Jetstream.new(service, jet_opts)
   else
     cursor = options[:cursor]&.to_i
-    sky = Skyfall::Firehose.new(host, :subscribe_repos, cursor)
+    sky = Skyfall::Firehose.new(service, :subscribe_repos, cursor)
   end
 
-  # Lifecycle logging
   sky.on_connecting { |url| puts "Connecting to #{url}..." }
   sky.on_connect    { puts "Connected" }
   sky.on_disconnect { puts "Disconnected" }
   sky.on_reconnect  { puts "Connection lost, trying to reconnect..." }
-  sky.on_timeout    { puts "Connection stalled, triggering a reconnect..." } if sky.respond_to?(:on_timeout)
-  sky.on_error      { |e| warn "ERROR: #{e}" }
+  sky.on_timeout    { puts "Connection stalled, triggering a reconnect..." }
+  sky.on_error      { |e| puts "ERROR: #{e}" }
 
-  # Message handler
   sky.on_message do |msg|
     next unless msg.type == :commit
+    next if options[:dids] && !options[:dids].include?(msg.repo)
 
-    did = if msg.respond_to?(:repo) && msg.repo
-            msg.repo
-          elsif msg.respond_to?(:did)
-            msg.did
-          else
-            nil
-          end
-
-    if !options[:dids].empty? && (!did || !options[:dids].include?(did))
-      next
-    end
-
-    ts = msg.time ? msg.time.getlocal.iso8601 : 'unknown-time'
+    time = msg.time.getlocal.iso8601
 
     msg.operations.each do |op|
-      # collection filter (still applied client-side, in case server doesn't)
-      if !options[:collections].empty? &&
-         !options[:collections].include?(op.collection)
-        next
-      end
+      next if options[:collections] && !options[:collections].include?(op.collection)
 
-      line = "[#{ts}] #{did || '-'} :#{op.action} #{op.collection} #{op.rkey}"
-
-      if op.respond_to?(:raw_record) && op.raw_record && !op.raw_record.empty?
-        # compact JSON on one line
-        line << " " << JSON.generate(op.raw_record)
-      end
-
-      puts line
+      json = op.raw_record && JSON.generate(op.raw_record)
+      puts "[#{time}] #{msg.repo} #{op.action.inspect} #{op.collection} #{op.rkey} #{json}"
     end
   end
 
-  # Clean disconnect on Ctrl+C
   trap('SIGINT') do
     puts 'Disconnecting...'
     sky.disconnect
···
   sky.connect
 end
 
-# ---- main dispatcher ----
-
 if ARGV.empty?
-  puts global_help
-  exit 0
+  print_help
+  exit
 end
 
 cmd = ARGV.shift
 
 case cmd
 when 'help', '--help', '-h'
-  puts global_help
-  exit 0
+  print_help
 when 'version', '--version'
-  puts VERSION
-  exit 0
+  puts "RatProto #{VERSION} 🐀"
 when 'fetch'
-  do_fetch(ARGV)
+  run_fetch(ARGV)
 when 'resolve'
-  do_resolve(ARGV)
+  run_resolve(ARGV)
 when 'stream'
-  do_stream(ARGV)
+  run_stream(ARGV)
 else
-  abort_with_help("unknown command: #{cmd}")
+  abort_with_error "Error: unknown command: #{cmd}"
 end