wavesync 1.0.0.alpha2 → 1.0.0.alpha4

data/lib/wavesync/audio.rb

@@ -1,52 +1,131 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
-require 'streamio-ffmpeg'
 require 'securerandom'
 require 'tmpdir'
 require 'fileutils'
-require 'taglib'
+require_relative 'logger'
 
 module Wavesync
   class Audio
     SUPPORTED_FORMATS = %w[.m4a .mp3 .wav .aif .aiff].freeze
 
+    #: (String library_path) -> Array[String]
     def self.find_all(library_path)
       Dir.glob(File.join(library_path, '**', '*'))
-         .select { |f| SUPPORTED_FORMATS.include?(File.extname(f).downcase) }
+         .select { |file| SUPPORTED_FORMATS.include?(File.extname(file).downcase) }
+         .sort_by(&:downcase)
     end
 
+    #: (String file_path) -> void
     def initialize(file_path)
-      @file_path = file_path
-      @file_ext = File.extname(@file_path).downcase
-      @audio = FFMPEG::Movie.new(file_path)
+      @file_path = file_path #: String
+      @file_ext = File.extname(@file_path).downcase #: String
+      @audio = Wavesync::FFMPEG::Probe.new(file_path) #: Wavesync::FFMPEG::Probe
     end
 
+    #: () -> Float
     def duration
       @audio.duration
     end
 
+    #: () -> Integer?
     def sample_rate
-      @sample_rate ||= @audio.audio_sample_rate
+      @sample_rate ||= @audio.sample_rate
     end
 
+    #: () -> Integer?
     def bit_depth
-      @bit_depth ||= calculate_bit_depth
+      @bit_depth ||= @audio.bit_depth
     end
 
+    #: () -> Integer?
+    def bitrate
+      @bitrate ||= @audio.bitrate
+    end
+
+    #: () -> (String | Integer)?
     def bpm
       return @bpm if defined?(@bpm)
 
       @bpm = bpm_from_file
     end
 
+    #: () -> AudioFormat
     def format
       AudioFormat.new(
         file_type: @file_ext.delete_prefix('.'),
         sample_rate: sample_rate,
-        bit_depth: bit_depth
+        bit_depth: bit_depth,
+        bitrate: bitrate
       )
     end
 
+    #: () -> Array[{identifier: Integer, sample_offset: Integer, label: String?}]
+    def cue_points
+      return [] unless @file_ext == '.wav'
+
+      CueChunk.read(@file_path)
+    end
+
+    #: (Array[{identifier: Integer, sample_offset: Integer, label: String?}] cue_points) -> void
+    def write_cue_points(cue_points)
+      temp_path = "#{@file_path}.tmp"
+      CueChunk.write(@file_path, temp_path, cue_points)
+      FileUtils.mv(temp_path, @file_path)
+    end
+
+    ID3V2_FRAME_TITLE = 'TIT2'
+    ID3V2_FRAME_ARTIST = 'TPE1'
+    ID3V2_FRAME_ALBUM = 'TALB'
+    ID3V2_FRAME_ALBUM_ARTIST = 'TPE2'
+    ID3V2_FRAME_GENRE = 'TCON'
+    ID3V2_FRAME_COMPOSER = 'TCOM'
+    ID3V2_FRAME_ENCODED_BY = 'TENC'
+    ID3V2_FRAME_COMPILATION = 'TCMP'
+
+    FRAME_ID_TO_FFMPEG_KEY = {
+      ID3V2_FRAME_TITLE => 'title',
+      ID3V2_FRAME_ARTIST => 'artist',
+      ID3V2_FRAME_ALBUM => 'album',
+      ID3V2_FRAME_ALBUM_ARTIST => 'album_artist',
+      ID3V2_FRAME_GENRE => 'genre',
+      ID3V2_FRAME_COMPOSER => 'composer',
+      ID3V2_FRAME_ENCODED_BY => 'encoded_by',
+      ID3V2_FRAME_COMPILATION => 'compilation'
+    }.freeze
+
+    FFMPEG_KEY_TO_FRAME_ID = FRAME_ID_TO_FFMPEG_KEY.invert.freeze
+
+    COMBINING_MARKS = /\p{Mn}/
+
+    #: () -> Hash[String, String]
+    def transliterated_tag_changes
+      current_tags = @audio.tags
+      changes = {} #: Hash[String, String]
+
+      FRAME_ID_TO_FFMPEG_KEY.each_value do |ffmpeg_key|
+        current_value = find_in_tags(current_tags, ffmpeg_key)
+        next if current_value.nil?
+
+        transliterated = transliterate(current_value)
+        changes[ffmpeg_key] = transliterated if transliterated != current_value
+      end
+
+      changes
+    end
+
+    #: () -> void
+    def transliterate_tags
+      return unless @file_ext == '.mp3'
+
+      changes = transliterated_tag_changes
+      return if changes.empty?
+
+      write_file_metadata(changes)
+    end
+
+    #: (String | Integer | Float bpm) -> void
     def write_bpm(bpm)
       case @file_ext
       when '.m4a'
@@ -61,20 +140,26 @@ module Wavesync
       @bpm = bpm
     end
 
-    def transcode(target_path, target_sample_rate: nil, target_file_type: nil, target_bit_depth: nil, padding_seconds: nil)
-      options = build_transcode_options(target_sample_rate, target_bit_depth, padding_seconds)
+    #: (String target_path, ?target_sample_rate: Integer?, ?target_file_type: String?, ?target_bit_depth: Integer?, ?padding_seconds: Numeric?, ?metadata: Hash[String, String], ?target_bitrate: Integer) ?{ (String) -> void } -> bool
+    def transcode(target_path, target_sample_rate: nil, target_file_type: nil, target_bit_depth: nil, padding_seconds: nil, metadata: {}, target_bitrate: 192)
       ext = target_file_type || @file_ext.delete_prefix('.')
-      temp_path = File.join(
-        Dir.tmpdir,
-        "wavesync_transcode_#{SecureRandom.hex}.#{ext}"
-      )
+      temp_path = File.join(Dir.tmpdir, "wavesync_transcode_#{SecureRandom.hex}.#{ext}")
 
       begin
-        @audio.transcode(temp_path, options)
+        command = Wavesync::FFMPEG.new.input(@file_path).audio_codec(transcode_codec(ext, target_bit_depth))
+        command.audio_bitrate("#{target_bitrate}k") if ext == 'mp3'
+        command.sample_rate(target_sample_rate) if target_sample_rate
+        if padding_seconds&.positive?
+          total_duration = @audio.duration + padding_seconds
+          command.audio_filter("apad=whole_dur=#{total_duration.round(6)}")
+        end
+        metadata.each { |key, value| command.metadata(key, value) }
+        command.run(temp_path)
+        yield temp_path if block_given?
         FileUtils.install(temp_path, target_path)
         true
-      rescue Errno::ENOENT
-        puts 'Errno::ENOENT'
+      rescue Errno::ENOENT => e
+        Logger.log_error(e, call_site: 'Audio#transcode', arguments: { target_path:, target_sample_rate:, target_file_type:, target_bit_depth:, padding_seconds:, target_bitrate: })
         false
       ensure
         FileUtils.rm_f(temp_path)
@@ -83,39 +168,14 @@ module Wavesync
 
     private
 
-    def calculate_bit_depth
-      data = @audio.metadata
-      return nil unless data && data[:streams]
-
-      audio_stream = data[:streams].find { |s| s[:codec_type] == 'audio' }
-      return nil unless audio_stream
-
-      bits_per_sample = audio_stream[:bits_per_sample]
-      return bits_per_sample if bits_per_sample&.positive?
-
-      nil
-    end
-
-    def build_transcode_options(target_sample_rate, target_bit_depth, padding_seconds = nil)
-      options = { custom: %w[-loglevel warning -nostats -hide_banner] }
-
-      if target_bit_depth == 24
-        options[:audio_codec] = 'pcm_s24le'
-      elsif target_bit_depth == 16
-        options[:audio_codec] = 'pcm_s16le'
-      end
-
-      options[:audio_codec] = 'pcm_s24le'
-      options[:audio_sample_rate] = target_sample_rate if target_sample_rate
+    #: (String target_file_type, Integer? target_bit_depth) -> String
+    def transcode_codec(target_file_type, target_bit_depth)
+      return 'libmp3lame' if target_file_type == 'mp3'
 
-      if padding_seconds&.positive?
-        total_duration = @audio.duration + padding_seconds
-        options[:custom] += ['-af', "apad=whole_dur=#{total_duration.round(6)}"]
-      end
-
-      options
+      target_bit_depth == 16 ? 'pcm_s16le' : 'pcm_s24le'
     end
 
+    #: () -> (String | Integer)?
     def bpm_from_file
       case @file_ext
       when '.m4a'
@@ -129,84 +189,87 @@ module Wavesync
       end
     end
 
+    #: () -> Integer?
     def bpm_from_m4a
-      TagLib::MP4::File.open(@file_path) do |file|
-        tag = file.tag
-        return bpm_from_item_map(tag) if tag
-      end
+      value = find_in_tags(@audio.tags, 'BPM')
+      return nil if value.nil?
+
+      int_value = value.to_i
+      int_value.zero? ? nil : int_value
     end
 
+    #: () -> String?
     def bpm_from_mp3
-      TagLib::MPEG::File.open(@file_path) do |file|
-        tag = file.id3v2_tag
-        return bpm_from_frame_list(tag) if tag
-      end
+      value = find_in_tags(@audio.tags, 'TBPM')
+      value&.then { |v| v.empty? ? nil : v }
     end
 
+    #: () -> (String | Integer)?
     def bpm_from_wav
-      TagLib::RIFF::WAV::File.open(@file_path) do |file|
-        tag = file.id3v2_tag
-        bpm_from_frame_list = bpm_from_frame_list(tag) if tag
-        return bpm_from_frame_list if bpm_from_frame_list
-      end
+      value = find_in_tags(@audio.tags, 'TBPM')
+      return value if value && !value.empty?
 
       bpm_from_acid_chunk
     end
 
+    #: () -> String?
     def bpm_from_aiff
-      TagLib::RIFF::AIFF::File.open(@file_path) do |file|
-        tag = file.tag
-        return bpm_from_frame_list(tag) if tag
-      end
+      value = find_in_tags(@audio.tags, 'TBPM')
+      value&.then { |v| v.empty? ? nil : v }
     end
 
-    def bpm_from_item_map(tag)
-      tmpo = tag.item_map['tmpo']&.to_int
-      tmpo&.zero? ? nil : tmpo
-    end
-
-    def bpm_from_frame_list(tag)
-      tag.frame_list('TBPM').first&.to_s
+    #: (Hash[String, String] tags, String key) -> String?
+    def find_in_tags(tags, key)
+      tags.find { |k, _| k.casecmp(key).zero? }&.last
     end
 
+    #: () -> Integer?
     def bpm_from_acid_chunk
       tmpo = Wavesync::AcidChunk.read_bpm(@file_path).to_i
       tmpo&.zero? ? nil : tmpo
     end
 
+    #: (String | Integer | Float bpm) -> void
     def write_bpm_to_wav(bpm)
       temp_path = "#{@file_path}.tmp"
       AcidChunk.write_bpm(@file_path, temp_path, bpm)
       FileUtils.mv(temp_path, @file_path)
     end
 
+    #: (String | Integer | Float bpm) -> void
     def write_bpm_to_mp3(bpm)
-      TagLib::MPEG::File.open(@file_path) do |file|
-        write_id3v2_bpm(file.id3v2_tag(true), bpm)
-        file.save
-      end
+      write_file_metadata('TBPM' => bpm.to_s)
     end
 
+    #: (String | Integer | Float bpm) -> void
     def write_bpm_to_m4a(bpm)
-      TagLib::MP4::File.open(@file_path) do |file|
-        tag = file.tag
-        tag.item_map.insert('tmpo', TagLib::MP4::Item.from_int(bpm.to_i))
-        file.save
-      end
+      write_file_metadata('BPM' => bpm.to_i.to_s)
     end
 
+    #: (String | Integer | Float bpm) -> void
     def write_bpm_to_aiff(bpm)
-      TagLib::RIFF::AIFF::File.open(@file_path) do |file|
-        write_id3v2_bpm(file.tag, bpm)
-        file.save
-      end
+      write_file_metadata('TBPM' => bpm.to_s)
+    end
+
+    #: (Hash[String, String] metadata_hash) -> void
+    def write_file_metadata(metadata_hash)
+      ext = File.extname(@file_path)
+      temp_path = File.join(Dir.tmpdir, "wavesync_meta_#{SecureRandom.hex}#{ext}")
+      command = FFMPEG.new.input(@file_path).copy_streams.map_metadata(0)
+      command.movflags('+use_metadata_tags') if ext == '.m4a'
+      command.write_id3v2(1) if %w[.aif .aiff].include?(ext)
+      metadata_hash.each { |key, value| command.metadata(key, value) }
+      command.run(temp_path)
+      FileUtils.mv(temp_path, @file_path)
+    ensure
+      FileUtils.rm_f(temp_path)
     end
 
-    def write_id3v2_bpm(tag, bpm)
-      tag.remove_frames('TBPM')
-      frame = TagLib::ID3v2::TextIdentificationFrame.new('TBPM', TagLib::String::UTF8)
-      frame.text = bpm.to_s
-      tag.add_frame(frame)
+    #: (String string) -> String
+    def transliterate(string)
+      string
+        .unicode_normalize(:nfd)
+        .gsub(COMBINING_MARKS, '')
     end
   end
 end

data/lib/wavesync/audio_format.rb

@@ -1,12 +1,19 @@
 # frozen_string_literal: true
 
 module Wavesync
-  AudioFormat = Data.define(:file_type, :sample_rate, :bit_depth) do
+  AudioFormat = Data.define(:file_type, :sample_rate, :bit_depth, :bitrate) do
+    #: (file_type: String?, sample_rate: Integer?, bit_depth: Integer?, ?bitrate: Integer?) -> void
+    def initialize(file_type:, sample_rate:, bit_depth:, bitrate: nil)
+      super
+    end
+
+    #: (AudioFormat other) -> AudioFormat
     def merge(other)
       with(
         file_type: other.file_type || file_type,
         sample_rate: other.sample_rate || sample_rate,
-        bit_depth: other.bit_depth || bit_depth
+        bit_depth: other.bit_depth || bit_depth,
+        bitrate: other.bitrate || bitrate
       )
     end
   end

data/lib/wavesync/bpm_detector.rb

@@ -1,19 +1,26 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
-require 'shellwords'
+require_relative 'essentia_bpm_detector'
+require_relative 'percival_bpm_detector'
 
 module Wavesync
   class BpmDetector
+    CONFIDENCE_THRESHOLD = 2.0
+
+    #: () -> bool?
     def self.available?
-      system('which bpm > /dev/null 2>&1') && system('which ffmpeg > /dev/null 2>&1')
+      EssentiaBpmDetector.available? || PercivalBpmDetector.available?
     end
 
+    #: (String file_path) -> Integer?
     def self.detect(file_path)
-      output = `ffmpeg -i #{Shellwords.escape(file_path)} -ac 1 -ar 44100 -f f32le - 2>/dev/null | bpm`
-      bpm = output.strip.to_f
-      bpm.positive? ? bpm.round : nil
-    rescue StandardError
-      nil
+      if EssentiaBpmDetector.available?
+        essentia_result = EssentiaBpmDetector.detect(file_path)
+        return essentia_result[:bpm] if essentia_result && essentia_result[:confidence] > CONFIDENCE_THRESHOLD
+      end
+
+      PercivalBpmDetector.detect(file_path) if PercivalBpmDetector.available?
     end
   end
 end

data/lib/wavesync/cli.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 require_relative 'commands'
 
 module Wavesync
   class CLI
+    #: () -> void
     def self.start
+      Logger.capture_invocation(ARGV.dup)
       command_name = ARGV.first && !ARGV.first.start_with?('-') ? ARGV.shift : 'sync'
       command_class = Commands::ALL.find { |cmd| command_name == cmd.name }
 

data/lib/wavesync/commands/analyze.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 require 'optparse'
 
@@ -11,6 +12,7 @@ module Wavesync
       self.description = 'Detect and write BPM metadata to library tracks'
       self.options = [FORCE_OPTION].freeze
 
+      #: () -> void
       def run
         options, config = parse_options(banner: 'Usage: wavesync analyze [options]') do |opts, opts_hash|
           opts.on(*FORCE_OPTION.to_a) { opts_hash[:overwrite] = true }

data/lib/wavesync/commands/clear_cache.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'fileutils'
+require 'optparse'
+require_relative '../transport'
+
+module Wavesync
+  module Commands
+    class ClearCache < Command
+      DEVICE_OPTION = Option.new(short: '-d', long: '--device NAME', description: 'Clear cache for a specific device only')
+
+      self.name = 'clear-cache'
+      self.description = 'Delete the on-disk staging cache used for MTP devices'
+      self.options = [DEVICE_OPTION].freeze
+
+      #: () -> void
+      def run
+        options, config = parse_options(banner: 'Usage: wavesync clear-cache [options]') do |opts, opts_hash|
+          opts.on(*DEVICE_OPTION.to_a) { |value| opts_hash[:device] = value }
+        end
+
+        mtp_devices = config.device_configs.select { |device_config| device_config[:transport] == 'mtp' }
+        if options[:device]
+          mtp_devices = mtp_devices.select { |device_config| device_config[:name] == options[:device] }
+          if mtp_devices.empty?
+            puts "No MTP device named \"#{options[:device]}\" found in config."
+            exit 1
+          end
+        end
+
+        if mtp_devices.empty?
+          puts 'No MTP devices configured.'
+          return
+        end
+
+        mtp_devices.each { |device_config| clear_one(device_config[:name]) }
+      end
+
+      private
+
+      #: (String device_name) -> void
+      def clear_one(device_name)
+        path = Wavesync::Transport::Mtp.cache_path(device_name)
+        unless File.directory?(path)
+          puts "No cache for #{device_name} at #{path}"
+          return
+        end
+
+        size_bytes = directory_size(path)
+        FileUtils.rm_rf(path)
+        puts "Cleared #{path} (#{format_bytes(size_bytes)})"
+      end
+
+      #: (String path) -> Integer
+      def directory_size(path)
+        Dir.glob(File.join(path, '**', '*'))
+           .reject { |entry| File.directory?(entry) }
+           .sum { |entry| File.size(entry) }
+      end
+
+      #: (Integer bytes) -> String
+      def format_bytes(bytes)
+        units = %w[B KB MB GB TB]
+        size = bytes.to_f
+        unit_index = 0
+        while size >= 1024 && unit_index < units.length - 1
+          size /= 1024
+          unit_index += 1
+        end
+        unit_index.zero? ? "#{bytes} #{units[unit_index]}" : format('%<size>.1f %<unit>s', size: size, unit: units[unit_index])
+      end
+    end
+  end
+end

data/lib/wavesync/commands/command.rb

@@ -13,8 +13,9 @@ module Wavesync
         def subcommands = @subcommands || []
       end
 
+      #: (banner: String) ?{ (OptionParser, Hash[Symbol, untyped]) -> void } -> [Hash[Symbol, untyped], Config]
       def parse_options(banner:)
-        options = {}
+        options = {} #: Hash[Symbol, untyped]
         OptionParser.new do |opts|
           opts.banner = banner
           opts.on(*CONFIG_OPTION.to_a) { |value| options[:config] = value }
@@ -22,6 +23,8 @@ module Wavesync
         end.parse!
         config_path = options[:config] || Wavesync::Config::DEFAULT_PATH
         config = Commands.load_config(config_path)
+        Logger.configure(config.library)
+        Logger.log_invocation
         [options, config]
       end
     end

data/lib/wavesync/commands/help.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 require 'optparse'
 require 'rainbow'
@@ -11,6 +12,7 @@ module Wavesync
 
       DESCRIPTION_COLUMN = 23
 
+      #: () -> void
       def run
         subcommand_name = ARGV.shift
 
@@ -30,6 +32,7 @@ module Wavesync
 
       private
 
+      #: () -> void
       def show_general_help
         puts 'Usage: wavesync [command] [options]'
         puts ''
@@ -47,6 +50,7 @@ module Wavesync
         GLOBAL_OPTIONS.each { |option| puts format_option_line(option, indent: 2) }
       end
 
+      #: (untyped command) -> void
       def show_command_help(command)
         if command.subcommands.any?
           puts "Usage: wavesync #{command.name} <subcommand> [options]"
@@ -68,10 +72,12 @@ module Wavesync
         end
       end
 
+      #: (String name, String description) -> String
       def format_command_line(name, description)
         "  #{name.ljust(DESCRIPTION_COLUMN - 2)}#{description}"
       end
 
+      #: (untyped option, indent: Integer) -> String
       def format_option_line(option, indent:)
         key = "#{option.short}, #{option.long}"
         Rainbow("#{' ' * indent}#{key.ljust(DESCRIPTION_COLUMN - indent)}#{option.description}").darkgray

data/lib/wavesync/commands/pull.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'optparse'
+require_relative '../transport'
+
+module Wavesync
+  module Commands
+    class Pull < Command
+      DEVICE_OPTION = Option.new(short: '-d', long: '--device NAME', description: 'Name of device to pull from (as defined in config)')
+
+      self.name = 'pull'
+      self.description = 'Read cue points from device files and write them back into the source library'
+      self.options = [DEVICE_OPTION].freeze
+
+      #: () -> void
+      def run
+        options, config = parse_options(banner: 'Usage: wavesync pull [options]') do |opts, opts_hash|
+          opts.on(*DEVICE_OPTION.to_a) { |value| opts_hash[:device] = value }
+        end
+
+        device_pairs = Commands.resolve_device_pairs(config, device_name: options[:device])
+        scanner = Wavesync::Scanner.new(config.library)
+        ui = Wavesync::UI.new
+
+        device_pairs.each do |pair|
+          device_config = pair[0] #: { name: String, model: String, path: String, transport: String, mp3_bitrate: Integer }
+          device = pair[1] #: Wavesync::Device
+          transport = Wavesync::Transport.for(device_config)
+          Commands.with_mtp_retry(transport, device_config[:name]) do
+            next unless transport.is_a?(Wavesync::Transport::Mtp)
+
+            transport.prepare! do |index, total, relative_path|
+              ui.pull_staging_progress(index, total, device)
+              ui.file_progress(relative_path)
+            end
+          end
+          scanner.pull_cue_points(transport.working_directory, device)
+        end
+      end
+    end
+  end
+end

data/lib/wavesync/commands/setlist.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'optparse'
+
+module Wavesync
+  module Commands
+    class Setlist < Command
+      self.name = 'setlist'
+      self.subcommands = [
+        Subcommand.new(usage: 'setlist create NAME', description: 'Create a new setlist'),
+        Subcommand.new(usage: 'setlist edit NAME', description: 'Edit an existing setlist'),
+        Subcommand.new(usage: 'setlist list', description: 'List all setlists')
+      ].freeze
+
+      #: () -> void
+      def run
+        subcommand = ARGV.shift
+
+        _options, config = parse_options(banner: 'Usage: wavesync setlist <subcommand> [options]')
+
+        case subcommand
+        when 'create'
+          name = require_name('create')
+          if Wavesync::Setlist.exists?(config.library, name)
+            puts "Setlist '#{name}' already exists. Use 'wavesync setlist edit #{name}' to edit it."
+            exit 1
+          end
+          setlist = Wavesync::Setlist.new(config.library, name)
+          Wavesync::SetlistEditor.new(setlist, config.library).run
+        when 'edit'
+          name = require_name('edit')
+          unless Wavesync::Setlist.exists?(config.library, name)
+            puts "Setlist '#{name}' not found. Use 'wavesync setlist create #{name}' to create it."
+            exit 1
+          end
+          setlist = Wavesync::Setlist.load(config.library, name)
+          Wavesync::SetlistEditor.new(setlist, config.library).run
+        when 'list'
+          setlists = Wavesync::Setlist.all(config.library)
+          if setlists.empty?
+            puts 'No setlists found.'
+          else
+            setlists.each { |setlist| puts "#{setlist.name} (#{setlist.tracks.size} tracks)" }
+          end
+        else
+          puts "Unknown subcommand: #{subcommand || '(none)'}"
+          puts 'Available subcommands: create, edit, list'
+          exit 1
+        end
+      end
+
+      private
+
+      #: (String subcommand) -> String
+      def require_name(subcommand)
+        name = ARGV.shift
+        unless name
+          puts "Usage: wavesync setlist #{subcommand} <name>"
+          exit 1
+        end
+        name
+      end
+    end
+  end
+end