wavesync 1.0.0.alpha2 → 1.0.0.alpha4

data/lib/wavesync/transport/mtp.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require 'fileutils'
+require 'tmpdir'
+require 'yaml'
+require_relative '../libmtp'
+require_relative '../cue_chunk'
+require_relative '../logger'
+
+module Wavesync
+  module Transport
+    class Mtp
+      DEFAULT_CACHE_ROOT = File.join(Dir.home, '.cache', 'wavesync').freeze
+      MTP_ILLEGAL_CHARACTERS = %r{[<>:"/\\|?*\x00-\x1f]} #: Regexp
+      CACHE_DIR_ILLEGAL_CHARACTERS = /[^a-z0-9._-]/ #: Regexp
+      MANIFEST_FILENAME = '.manifest.yml'
+
+      attr_reader :working_directory #: String
+      attr_reader :device_path #: String
+      attr_reader :name #: String
+
+      #: (String name, ?cache_root: String) -> String
+      def self.cache_path(name, cache_root: DEFAULT_CACHE_ROOT)
+        File.join(cache_root, sanitize_dir_name(name))
+      end
+
+      #: (String name) -> String
+      def self.sanitize_dir_name(name)
+        sanitized = name.downcase.gsub(CACHE_DIR_ILLEGAL_CHARACTERS, '_')
+        sanitized.empty? ? 'device' : sanitized
+      end
+
+      #: ({ name: String, model: String, path: String, transport: String?, mp3_bitrate: Integer } device_config, ?libmtp: Libmtp, ?cache_root: String) -> void
+      def initialize(device_config, libmtp: Libmtp.new, cache_root: DEFAULT_CACHE_ROOT)
+        @name = device_config[:name]
+        @device_path = device_config[:path]
+        @libmtp = libmtp
+        @working_directory = self.class.cache_path(@name, cache_root: cache_root)
+        FileUtils.mkdir_p(@working_directory)
+      end
+
+      #: () ?{ (Integer, Integer, String) -> void } -> void
+      def prepare!(&progress)
+        device_files = @libmtp.files
+        folder_paths = build_folder_paths(@libmtp.folders)
+
+        candidates = device_files.filter_map do |device_file|
+          next unless wav?(device_file.filename)
+
+          relative_path = relative_path_for(device_file, folder_paths)
+          next unless relative_path
+
+          local_path = File.join(@working_directory, relative_path)
+          { device_file: device_file, relative_path: relative_path, local_path: local_path }
+        end
+
+        Dir.mktmpdir('wavesync_mtp_pull') do |tmpdir|
+          candidates.each_with_index do |candidate, index|
+            progress&.call(index, candidates.size, candidate[:relative_path])
+            pull_if_cues_differ(candidate, tmpdir)
+          end
+        end
+      end
+
+      #: () -> void
+      def begin_push!
+        @push_files_by_parent = @libmtp.files.group_by(&:parent_id)
+        @push_folders_by_parent = @libmtp.folders.group_by(&:parent_id)
+        @push_storage_id = primary_storage_id(@push_folders_by_parent)
+        @push_manifest = load_manifest
+      end
+
+      #: (String relative_path) -> void
+      def push_file!(relative_path)
+        files_by_parent = @push_files_by_parent
+        folders_by_parent = @push_folders_by_parent
+        storage_id = @push_storage_id
+        raise Libmtp::Error, 'push_file! called before begin_push!' unless files_by_parent && folders_by_parent && storage_id
+
+        local_path = File.join(@working_directory, relative_path)
+        return unless File.file?(local_path)
+
+        remote_path = join_remote_paths(@device_path, relative_path)
+        entry = { local_path: local_path, relative_path: relative_path, remote_path: remote_path } #: { local_path: String, relative_path: String, remote_path: String }
+        push_one(entry, files_by_parent: files_by_parent, folders_by_parent: folders_by_parent, storage_id: storage_id)
+      end
+
+      #: () -> void
+      def finish_push!
+        save_manifest if @push_manifest
+        @push_files_by_parent = nil
+        @push_folders_by_parent = nil
+        @push_storage_id = nil
+        @push_manifest = nil
+        @libmtp.close!
+      end
+
+      #: () ?{ (Integer, Integer, String) -> void } -> void
+      def commit!(&progress)
+        begin_push!
+        local_files = enumerate_local_files
+        local_files.each_with_index do |entry, index|
+          progress&.call(index, local_files.size, entry[:relative_path])
+          push_file!(entry[:relative_path])
+        end
+        finish_push!
+      end
+
+      private
+
+      #: () -> Array[{ local_path: String, relative_path: String, remote_path: String }]
+      def enumerate_local_files
+        Dir.glob(File.join(@working_directory, '**', '*'))
+           .reject { |path| File.directory?(path) }
+           .sort
+           .map do |local_path|
+             relative_path = local_path.sub(%r{\A#{Regexp.escape(@working_directory)}/?}, '')
+             remote_path = join_remote_paths(@device_path, relative_path)
+             { local_path: local_path, relative_path: relative_path, remote_path: remote_path }
+           end
+      end
+
+      #: ({ local_path: String, relative_path: String, remote_path: String } entry, files_by_parent: Hash[Integer, Array[Libmtp::DeviceFile]], folders_by_parent: Hash[Integer, Array[Libmtp::DeviceFolder]], storage_id: Integer) -> void
+      def push_one(entry, files_by_parent:, folders_by_parent:, storage_id:)
+        target_dir = File.dirname(entry[:remote_path])
+        parent_id = ensure_folder(target_dir, folders_by_parent: folders_by_parent, storage_id: storage_id)
+
+        filename = sanitize_for_mtp(File.basename(entry[:remote_path]))
+        existing = (files_by_parent[parent_id] || []).find { |file| sanitize_for_mtp(file.filename) == filename }
+
+        local_size = File.size(entry[:local_path])
+        manifest = @push_manifest || {} #: Hash[String, Integer]
+        manifest_size = manifest[entry[:relative_path]]
+
+        if existing && (manifest_size == local_size || (manifest_size.nil? && existing.size == local_size))
+          manifest[entry[:relative_path]] = local_size
+          return
+        end
+
+        if existing
+          Logger.log_event("MTP replacing (size mismatch device=#{existing.size} local=#{local_size}): #{entry[:relative_path]}")
+          @libmtp.delete_file(id: existing.id)
+          files_by_parent[parent_id]&.delete(existing)
+        else
+          Logger.log_event("MTP uploading new file (#{local_size} bytes): #{entry[:relative_path]}")
+        end
+
+        @libmtp.send_file(
+          local_path: entry[:local_path],
+          remote_filename: filename,
+          parent_id: parent_id,
+          storage_id: storage_id
+        )
+        manifest[entry[:relative_path]] = local_size
+      end
+
+      #: (String remote_path, folders_by_parent: Hash[Integer, Array[Libmtp::DeviceFolder]], storage_id: Integer) -> Integer
+      def ensure_folder(remote_path, folders_by_parent:, storage_id:)
+        parent_id = 0
+        path_components(remote_path).each do |raw_name|
+          name = sanitize_for_mtp(raw_name)
+          children = folders_by_parent[parent_id] || []
+          existing = children.find { |folder| sanitize_for_mtp(folder.name) == name }
+          if existing
+            parent_id = existing.folder_id
+          else
+            new_id = @libmtp.create_folder(name: name, parent_id: parent_id, storage_id: storage_id)
+            new_folder = Libmtp::DeviceFolder.new(folder_id: new_id, name: name, parent_id: parent_id, storage_id: storage_id)
+            (folders_by_parent[parent_id] ||= []) << new_folder
+            parent_id = new_id
+          end
+        end
+        parent_id
+      end
+
+      #: (String name) -> String
+      def normalize_unicode(name)
+        name.unicode_normalize(:nfc)
+      end
+
+      #: () -> String
+      def manifest_path
+        File.join(@working_directory, MANIFEST_FILENAME)
+      end
+
+      #: () -> Hash[String, Integer]
+      def load_manifest
+        return {} unless File.exist?(manifest_path)
+
+        data = YAML.safe_load_file(manifest_path)
+        data.is_a?(Hash) ? data : {}
+      rescue Psych::SyntaxError
+        {}
+      end
+
+      #: () -> void
+      def save_manifest
+        manifest = @push_manifest
+        return unless manifest
+
+        File.write(manifest_path, manifest.to_yaml)
+      end
+
+      #: (String name) -> String
+      def sanitize_for_mtp(name)
+        normalize_unicode(name).gsub(MTP_ILLEGAL_CHARACTERS, '')
+      end
+
+      #: (Hash[Integer, Array[Libmtp::DeviceFolder]] folders_by_parent) -> Integer
+      def primary_storage_id(folders_by_parent)
+        first_storage = folders_by_parent.values.flatten.map(&:storage_id).compact.first
+        raise Libmtp::DeviceNotFound, 'No MTP device detected. Connect the device and unmount it from any other app.' unless first_storage
+
+        first_storage
+      end
+
+      #: (String path) -> Array[String]
+      def path_components(path)
+        path.split('/').reject { |component| component.empty? || component == '.' }
+      end
+
+      #: (String left, String right) -> String
+      def join_remote_paths(left, right)
+        "#{left}/#{right}".split('/').reject(&:empty?).join('/')
+      end
+
+      #: (Array[Libmtp::DeviceFolder] folders) -> Hash[Integer, String]
+      def build_folder_paths(folders)
+        by_id = {} #: Hash[Integer, Libmtp::DeviceFolder]
+        folders.each { |folder| by_id[folder.folder_id] = folder }
+        paths = { 0 => '' } #: Hash[Integer, String]
+        folders.each { |folder| resolve_folder_path(folder.folder_id, by_id, paths) }
+        paths
+      end
+
+      #: (Integer folder_id, Hash[Integer, Libmtp::DeviceFolder] by_id, Hash[Integer, String] paths) -> String?
+      def resolve_folder_path(folder_id, by_id, paths)
+        return paths[folder_id] if paths.key?(folder_id)
+
+        folder = by_id[folder_id]
+        return nil unless folder
+
+        parent_path = resolve_folder_path(folder.parent_id, by_id, paths) || ''
+        full_path = parent_path.empty? ? folder.name : "#{parent_path}/#{folder.name}"
+        paths[folder_id] = full_path
+        full_path
+      end
+
+      #: (Libmtp::DeviceFile device_file, Hash[Integer, String] folder_paths) -> String?
+      def relative_path_for(device_file, folder_paths)
+        folder_path = folder_paths[device_file.parent_id]
+        return nil unless folder_path
+
+        full_path = folder_path.empty? ? device_file.filename : "#{folder_path}/#{device_file.filename}"
+        device_root = path_components(@device_path).join('/')
+        return full_path if device_root.empty?
+        return full_path[(device_root.length + 1)..] if full_path.start_with?("#{device_root}/")
+
+        nil
+      end
+
+      #: (String filename) -> bool
+      def wav?(filename)
+        File.extname(filename).downcase == '.wav'
+      end
+
+      #: ({ device_file: Libmtp::DeviceFile, relative_path: String, local_path: String } candidate, String tmpdir) -> void
+      def pull_if_cues_differ(candidate, tmpdir)
+        device_file = candidate[:device_file]
+        local_path = candidate[:local_path]
+        tmp_path = File.join(tmpdir, "#{device_file.id}.wav")
+
+        @libmtp.get_file(id: device_file.id, local_path: tmp_path)
+
+        device_cues = CueChunk.read(tmp_path)
+        local_cues = File.exist?(local_path) ? CueChunk.read(local_path) : [] #: Array[{identifier: Integer, sample_offset: Integer, label: String?}]
+        return if CueChunk.same?(device_cues, local_cues)
+
+        FileUtils.mkdir_p(File.dirname(local_path))
+        FileUtils.mv(tmp_path, local_path)
+      end
+    end
+  end
+end

data/lib/wavesync/transport.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Wavesync
+  module Transport
+    SUPPORTED_KINDS = %w[filesystem mtp].freeze
+
+    #: ({ name: String, model: String, path: String, transport: String?, mp3_bitrate: Integer } device_config) -> (Filesystem | Mtp)
+    def self.for(device_config)
+      kind = device_config[:transport] || 'filesystem'
+      case kind
+      when 'filesystem' then Filesystem.new(device_config)
+      when 'mtp' then Mtp.new(device_config)
+      else raise ArgumentError, "Unsupported transport: #{kind.inspect}. Supported: #{SUPPORTED_KINDS.join(', ')}"
+      end
+    end
+  end
+end
+
+require_relative 'transport/filesystem'
+require_relative 'transport/mtp'

data/lib/wavesync/ui.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 require 'tty-cursor'
 require 'tty-prompt'
@@ -15,12 +16,14 @@ module Wavesync
       extra: :deepskyblue
     }.freeze
 
+    #: () -> void
     def initialize
-      @cursor = TTY::Cursor
-      @sticky_lines = []
-      @prompt = TTY::Prompt.new(interrupt: :exit, active_color: :red)
+      @cursor = TTY::Cursor #: untyped
+      @sticky_lines = [] #: Array[String]
+      @prompt = TTY::Prompt.new(interrupt: :exit, active_color: :red) #: untyped
     end
 
+    #: (String filename) -> void
     def file_progress(filename)
       path = Pathname.new(filename)
       file_stem = path.basename(path.extname).to_s
@@ -29,6 +32,7 @@ module Wavesync
       sticky(in_color(file_stem, :tertiary), 2)
     end
 
+    #: (Integer index, Integer total_count, Device device) -> void
     def sync_progress(index, total_count, device)
       parts = [
         in_color("wavesync #{device.name}", :primary),
@@ -38,11 +42,12 @@ module Wavesync
       sticky(parts.join(' '), 0)
     end
 
-    def conversion_progress(source_format, target_format)
+    #: (AudioFormat source_format, AudioFormat target_format, Integer mp3_bitrate) -> void
+    def conversion_progress(source_format, target_format, mp3_bitrate)
       effective = source_format.merge(target_format)
 
-      source_info = audio_info(source_format.sample_rate, source_format.bit_depth)
-      target_info = audio_info(effective.sample_rate, effective.bit_depth)
+      source_info = audio_info(source_format)
+      target_info = target_audio_info(effective, mp3_bitrate)
 
       formatted_line = in_color(
         "Converting #{source_format.file_type} (#{source_info}) ⇢ #{effective.file_type} (#{target_info})", :highlight
@@ -50,16 +55,20 @@ module Wavesync
       sticky(formatted_line, 3)
     end
 
+    #: (AudioFormat source_format) -> void
     def copy(source_format)
-      info = audio_info(source_format.sample_rate, source_format.bit_depth)
+      info = audio_info(source_format)
 
       sticky(in_color("Copying #{source_format.file_type} (#{info})", :highlight), 3)
     end
 
-    def skip
-      sticky(in_color('↷ Skipping, already synced', :highlight), 3)
+    #: (?staged: bool) -> void
+    def skip(staged: false)
+      message = staged ? '↷ Already in cache' : '↷ Already on device'
+      sticky(in_color(message, :highlight), 3)
     end
 
+    #: ((String | Integer)? tbpm, ?original_bars: Integer?, ?target_bars: Integer?) -> void
     def bpm(tbpm, original_bars: nil, target_bars: nil)
       if tbpm.nil?
         sticky('', 4)
@@ -71,6 +80,27 @@ module Wavesync
       end
     end
 
+    #: (Integer index, Integer total_count, Device device) -> void
+    def pull_progress(index, total_count, device)
+      parts = [
+        in_color("wavesync pull #{device.name}", :primary),
+        in_color("#{index + 1}/#{total_count}", :extra)
+      ]
+
+      sticky(parts.join(' '), 0)
+    end
+
+    #: (Integer index, Integer total_count, Device device) -> void
+    def pull_staging_progress(index, total_count, device)
+      parts = [
+        in_color("wavesync pull #{device.name} (staging)", :primary),
+        in_color("#{index + 1}/#{total_count}", :extra)
+      ]
+
+      sticky(parts.join(' '), 0)
+    end
+
+    #: (Integer index, Integer total_count) -> void
     def analyze_progress(index, total_count)
       parts = [
         in_color('wavesync analyze', :primary),
@@ -79,29 +109,35 @@ module Wavesync
       sticky(parts.join(' '), 0)
     end
 
+    #: (String file, (String | Integer)? bpm) -> void
     def analyze_skip(file, bpm)
       set_analyze_file_stickies(file, in_color("↷ #{bpm} BPM already set", :highlight))
     end
 
+    #: (String file, Integer? bpm) -> void
     def analyze_result(file, bpm)
       label = bpm ? in_color("#{bpm} BPM", :highlight) : in_color('No BPM detected', :highlight)
       set_analyze_file_stickies(file, label)
     end
 
+    #: (String message) -> bool
     def confirm(message)
       print in_color(message, :secondary)
       response = $stdin.gets.to_s.strip.downcase
       response == 'y'
     end
 
+    #: (String label, Array[String] options) -> String
     def select(label, options)
       @prompt.select(label, options, cycle: true)
     end
 
+    #: (String text, Symbol key) -> String
     def color(text, key)
       in_color(text, key)
     end
 
+    #: () -> void
     def clear
       print @cursor.clear_screen
       print @cursor.move_to(0, 0)
@@ -109,26 +145,41 @@ module Wavesync
 
     private
 
-    def audio_info(sample_rate, bit_depth)
+    #: (AudioFormat format) -> String
+    def audio_info(format)
+      quality = format.file_type == 'mp3' ? format.bitrate&.to_s : format.bit_depth&.to_s
       [
-        sample_rate_to_khz(sample_rate),
-        bit_depth
+        sample_rate_to_khz(format.sample_rate),
+        quality
       ].compact.join('/')
     end
 
+    #: (AudioFormat format, Integer mp3_bitrate) -> String
+    def target_audio_info(format, mp3_bitrate)
+      quality = format.file_type == 'mp3' ? mp3_bitrate.to_s : format.bit_depth&.to_s
+      [
+        sample_rate_to_khz(format.sample_rate),
+        quality
+      ].compact.join('/')
+    end
+
+    #: (String string, Symbol key) -> String
     def in_color(string, key)
       Rainbow(string).color(THEME[key])
     end
 
+    #: (String text, Integer index) -> void
     def sticky(text, index)
       set_sticky(text, index)
       redraw
     end
 
+    #: (String text, Integer index) -> void
     def set_sticky(text, index)
       @sticky_lines[index] = text
     end
 
+    #: (String file, String label) -> void
     def set_analyze_file_stickies(file, label)
       path = Pathname.new(file)
       set_sticky(in_color(path.parent.basename.to_s, :secondary), 1)
@@ -137,13 +188,17 @@ module Wavesync
       redraw
     end
 
+    #: () -> void
     def redraw
       print @cursor.clear_screen
       print @cursor.move_to(0, 0)
       puts @sticky_lines.join("\n")
     end
 
+    #: (Integer? rate) -> String?
     def sample_rate_to_khz(rate)
+      return nil unless rate
+
       khz = rate.to_f / 1000
       (khz % 1).zero? ? khz.to_i.to_s : khz.round(1).to_s
     end

data/lib/wavesync/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 module Wavesync
-  VERSION = '1.0.0.alpha2'
+  VERSION = '1.0.0.alpha4'
 end

data/lib/wavesync.rb

@@ -3,9 +3,12 @@
 module Wavesync
 end
 
+require 'wavesync/logger'
 require 'wavesync/version'
 require 'wavesync/acid_chunk'
+require 'wavesync/cue_chunk'
 require 'wavesync/audio_format'
+require 'wavesync/ffmpeg'
 require 'wavesync/audio'
 require 'wavesync/track_padding'
 require 'wavesync/config'
@@ -13,10 +16,12 @@ require 'wavesync/device'
 require 'wavesync/ui'
 require 'wavesync/path_resolver'
 require 'wavesync/file_converter'
+require 'wavesync/libmtp'
+require 'wavesync/transport'
 require 'wavesync/scanner'
 require 'wavesync/bpm_detector'
 require 'wavesync/analyzer'
-require 'wavesync/set'
-require 'wavesync/set_editor'
+require 'wavesync/setlist'
+require 'wavesync/setlist_editor'
 require 'wavesync/commands'
 require 'wavesync/cli'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wavesync
 version: !ruby/object:Gem::Version
-  version: 1.0.0.alpha2
+  version: 1.0.0.alpha4
 platform: ruby
 authors:
 - Andreas Zecher
@@ -37,34 +37,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.1'
-- !ruby/object:Gem::Dependency
-  name: streamio-ffmpeg
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: taglib-ruby
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: tty-cursor
   requirement: !ruby/object:Gem::Requirement
@@ -111,18 +83,31 @@ files:
 - lib/wavesync/cli.rb
 - lib/wavesync/commands.rb
 - lib/wavesync/commands/analyze.rb
+- lib/wavesync/commands/clear_cache.rb
 - lib/wavesync/commands/command.rb
 - lib/wavesync/commands/help.rb
-- lib/wavesync/commands/set.rb
+- lib/wavesync/commands/pull.rb
+- lib/wavesync/commands/setlist.rb
 - lib/wavesync/commands/sync.rb
 - lib/wavesync/config.rb
+- lib/wavesync/cue_chunk.rb
 - lib/wavesync/device.rb
+- lib/wavesync/essentia_bpm_detector.rb
+- lib/wavesync/ffmpeg.rb
+- lib/wavesync/ffmpeg/probe.rb
 - lib/wavesync/file_converter.rb
+- lib/wavesync/libmtp.rb
+- lib/wavesync/logger.rb
 - lib/wavesync/path_resolver.rb
+- lib/wavesync/percival_bpm_detector.rb
+- lib/wavesync/python_venv.rb
 - lib/wavesync/scanner.rb
-- lib/wavesync/set.rb
-- lib/wavesync/set_editor.rb
+- lib/wavesync/setlist.rb
+- lib/wavesync/setlist_editor.rb
 - lib/wavesync/track_padding.rb
+- lib/wavesync/transport.rb
+- lib/wavesync/transport/filesystem.rb
+- lib/wavesync/transport/mtp.rb
 - lib/wavesync/ui.rb
 - lib/wavesync/version.rb
 homepage: https://github.com/pixelate/wavesync

data/lib/wavesync/commands/set.rb

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