gemba 0.1.1 → 0.2.0

data/lib/gemba/cli/commands/record.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Gemba
+  class CLI
+    module Commands
+      class Record
+        def initialize(argv, dry_run: false)
+          @argv = argv
+          @dry_run = dry_run
+        end
+
+        def call
+          options = parse
+
+          if options[:help]
+            puts options[:parser] unless @dry_run
+            return { command: :record, help: true }
+          end
+
+          unless options[:frames] && options[:rom]
+            $stderr.puts "Error: record requires --frames N and a ROM file"
+            $stderr.puts "Run 'gemba record --help' for usage"
+            exit 1
+          end
+
+          result = {
+            command: :record,
+            rom: options[:rom],
+            frames: options[:frames],
+            output: options[:output],
+            compression: options[:compression],
+            progress: options[:progress],
+            options: options.except(:parser)
+          }
+          return result if @dry_run
+
+          require "gemba/headless"
+
+          total = options[:frames]
+
+          HeadlessPlayer.open(options[:rom]) do |player|
+            rec_path = options[:output] ||
+              "#{Config.rom_id(player.game_code, player.checksum)}.grec"
+
+            rec_opts = {}
+            rec_opts[:compression] = options[:compression] if options[:compression]
+            player.start_recording(rec_path, **rec_opts)
+
+            if options[:progress]
+              last_print = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+              player.step(total) do |frame|
+                now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+                if frame == total || now - last_print >= 0.5
+                  pct = frame * 100.0 / total
+                  $stderr.print "\rRecording: #{frame}/#{total} (#{'%.1f' % pct}%)\e[K"
+                  last_print = now
+                end
+              end
+              $stderr.print "\r\e[K"
+            else
+              player.step(total)
+            end
+
+            player.stop_recording
+
+            info = RecorderDecoder.stats(rec_path)
+            puts "Recorded #{info[:frame_count]} frames to #{rec_path}"
+            puts "  Duration:   #{'%.1f' % info[:duration]}s"
+            puts "  Avg change: #{'%.1f' % info[:avg_change_pct]}%/frame"
+            puts "  Uncompressed: #{format_size(info[:raw_video_size])} (encode input)"
+            puts "  .grec size: #{format_size(File.size(rec_path))}"
+          end
+        end
+
+        def parse
+          options = {}
+          argv = @argv.dup
+
+          parser = OptionParser.new do |o|
+            o.banner = "Usage: gemba record [options] ROM_FILE"
+            o.separator ""
+            o.separator "Record video+audio to a .grec file (headless, no GUI)."
+            o.separator ""
+
+            o.on("--frames N", Integer, "Number of frames to record (required)") { |v| options[:frames] = v }
+            o.on("-o", "--output PATH", "Output .grec path (default: ROM_ID.grec)") { |v| options[:output] = v }
+            o.on("-c", "--compression N", Integer, "Zlib level 1-9 (default: 1)") { |v| options[:compression] = v.clamp(1, 9) }
+            o.on("--progress", "Show recording progress") { options[:progress] = true }
+            o.on("-h", "--help", "Show this help") { options[:help] = true }
+          end
+
+          parser.parse!(argv)
+          options[:rom] = File.expand_path(argv.first) if argv.first
+          options[:parser] = parser
+          options
+        end
+
+        private
+
+        def format_size(bytes)
+          if bytes >= 1_073_741_824
+            "#{'%.1f' % (bytes / 1_073_741_824.0)} GB"
+          elsif bytes >= 1_048_576
+            "#{'%.1f' % (bytes / 1_048_576.0)} MB"
+          else
+            "#{'%.1f' % (bytes / 1024.0)} KB"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gemba/cli/commands/replay.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Gemba
+  class CLI
+    module Commands
+      class Replay
+        def initialize(argv, dry_run: false)
+          @argv = argv
+          @dry_run = dry_run
+        end
+
+        def call
+          options = parse
+
+          if options[:help]
+            puts options[:parser] unless @dry_run
+            return { command: :replay, help: true }
+          end
+
+          if options[:list]
+            list_recordings unless @dry_run
+            return { command: :replay_list }
+          end
+
+          unless options[:gir]
+            $stderr.puts "Error: replay requires a .gir file"
+            $stderr.puts "Run 'gemba replay --help' for usage"
+            exit 1
+          end
+
+          gir_path = File.expand_path(options[:gir])
+
+          result = {
+            command: options[:headless] ? :replay_headless : :replay,
+            gir: gir_path,
+            rom: options[:rom],
+            sound: options.fetch(:sound, true),
+            fullscreen: options[:fullscreen],
+            headless: options[:headless],
+            progress: options[:progress],
+            options: options.except(:parser)
+          }
+          return result if @dry_run
+
+          if options[:headless]
+            run_headless(gir_path, options)
+          else
+            run_gui(gir_path, options)
+          end
+        end
+
+        def parse
+          options = {}
+          argv = @argv.dup
+
+          parser = OptionParser.new do |o|
+            o.banner = "Usage: gemba replay [options] GIR_FILE [ROM_FILE]"
+            o.separator ""
+            o.separator "Replay a .gir input recording."
+            o.separator "ROM is read from the .gir header; override with ROM_FILE."
+            o.separator ""
+
+            o.on("-l", "--list", "List available .gir recordings") { options[:list] = true }
+            o.on("--headless", "Run without GUI (print summary and exit)") { options[:headless] = true }
+            o.on("--progress", "Show progress (headless only)") { options[:progress] = true }
+            o.on("-f", "--fullscreen", "Start in fullscreen") { options[:fullscreen] = true }
+            o.on("--no-sound", "Disable audio") { options[:sound] = false }
+            o.on("-h", "--help", "Show this help") { options[:help] = true }
+          end
+
+          parser.parse!(argv)
+          options[:gir] = argv.shift
+          options[:rom] = argv.shift
+          options[:parser] = parser
+          options
+        end
+
+        private
+
+        def run_headless(gir_path, options)
+          require "gemba/headless"
+
+          rom_path = options[:rom]
+          unless rom_path
+            replayer = Gemba::InputReplayer.new(gir_path)
+            rom_path = replayer.rom_path
+            unless rom_path
+              $stderr.puts "Error: .gir has no rom_path in header; pass ROM_FILE explicitly"
+              exit 1
+            end
+          end
+          rom_path = File.expand_path(rom_path)
+
+          Gemba::HeadlessPlayer.open(rom_path) do |player|
+            if options[:progress]
+              replayer = Gemba::InputReplayer.new(gir_path)
+              total = replayer.frame_count
+              last_print = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+              player.replay(gir_path) do |_mask, idx|
+                now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+                frame = idx + 1
+                if frame == total || now - last_print >= 0.5
+                  pct = frame * 100.0 / total
+                  $stderr.print "\rReplaying: #{frame}/#{total} (#{'%.1f' % pct}%)\e[K"
+                  last_print = now
+                end
+              end
+              $stderr.print "\r\e[K"
+            else
+              player.replay(gir_path)
+            end
+
+            puts "Replayed #{gir_path} (#{Gemba::InputReplayer.new(gir_path).frame_count} frames)"
+          end
+        end
+
+        def run_gui(gir_path, options)
+          require "gemba"
+
+          sound = options.fetch(:sound, true)
+          ReplayPlayer.new(gir_path,
+                           sound: sound,
+                           fullscreen: options[:fullscreen]).run
+        end
+
+        def list_recordings
+          require "gemba/headless"
+
+          dir = Config.default_recordings_dir
+          unless File.directory?(dir)
+            puts "No recordings directory found at #{dir}"
+            return
+          end
+
+          gir_files = Dir.glob(File.join(dir, '*.gir')).sort
+          if gir_files.empty?
+            puts "No .gir recordings in #{dir}"
+            return
+          end
+
+          by_rom = {}
+          gir_files.each do |path|
+            replayer = InputReplayer.new(path)
+            key = replayer.game_code || "unknown"
+            (by_rom[key] ||= []) << { path: path, frames: replayer.frame_count }
+          end
+
+          by_rom.each do |game_code, entries|
+            puts "#{game_code}:"
+            entries.each do |entry|
+              puts "  #{entry[:path]}  (#{entry[:frames]} frames)"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gemba/cli/commands/retro_achievements.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Gemba
+  class CLI
+    module Commands
+      class RetroAchievements
+        RA_SUBCOMMANDS = %w[login verify logout achievements].freeze
+
+        def initialize(argv, dry_run: false, config: nil, requester: nil)
+          @argv      = argv
+          @dry_run   = dry_run
+          @config    = config
+          @requester = requester
+        end
+
+        def call
+          options = parse
+
+          if options[:help] || options[:subcommand].nil?
+            puts options[:parser] unless @dry_run
+            return { command: :ra, help: true, subcommand: options[:subcommand] }
+          end
+
+          result = { command: :"ra_#{options[:subcommand]}", **options.except(:parser) }
+          return result if @dry_run
+
+          require "gemba"
+          require "gemba/achievements/retro_achievements/cli_sync_requester"
+
+          config    = @config    || Gemba.user_config
+          requester = @requester || Gemba::Achievements::RetroAchievements::CliSyncRequester.new
+
+          case options[:subcommand]
+          when :login        then login(options,        config: config, requester: requester)
+          when :verify       then verify(               config: config, requester: requester)
+          when :logout       then logout(               config: config)
+          when :achievements then achievements(options, config: config, requester: requester)
+          end
+        end
+
+        def parse
+          argv = @argv.dup
+          sub  = RA_SUBCOMMANDS.include?(argv.first) ? argv.shift.to_sym : nil
+
+          options = { subcommand: sub }
+
+          parser = OptionParser.new do |o|
+            case sub
+            when :login
+              o.banner = "Usage: gemba ra login --username USER [--password PASS]"
+              o.separator ""
+              o.separator "Log in to RetroAchievements and save credentials."
+              o.separator "Prompts for password if --password is not given."
+              o.separator ""
+              o.on("--username USER", "RetroAchievements username") { |v| options[:username] = v }
+              o.on("--password PASS", "Password (prompts if omitted)") { |v| options[:password] = v }
+            when :verify
+              o.banner = "Usage: gemba ra verify"
+              o.separator ""
+              o.separator "Verify stored RetroAchievements credentials are still valid."
+              o.separator ""
+            when :logout
+              o.banner = "Usage: gemba ra logout"
+              o.separator ""
+              o.separator "Clear stored RetroAchievements credentials."
+              o.separator ""
+            when :achievements
+              o.banner = "Usage: gemba ra achievements --rom PATH [--json]"
+              o.separator ""
+              o.separator "List achievements for a ROM."
+              o.separator ""
+              o.on("--rom PATH", "Path to the GBA ROM file") { |v| options[:rom] = File.expand_path(v) }
+              o.on("--json", "Output as JSON")               { options[:json] = true }
+            else
+              o.banner = "Usage: gemba ra <subcommand> [options]"
+              o.separator ""
+              o.separator "Subcommands: #{RA_SUBCOMMANDS.join(', ')}"
+              o.separator ""
+            end
+            o.on("-h", "--help", "Show this help") { options[:help] = true }
+          end
+
+          parser.parse!(argv)
+          options[:parser] = parser
+          options
+        end
+
+        private
+
+        def login(options, config:, requester:)
+          username = options[:username]
+          unless username
+            $stderr.puts "Error: --username USER is required"
+            $stderr.puts "Run 'gemba ra login --help' for usage"
+            exit 1
+          end
+
+          password = options[:password] || begin
+            require "io/console"
+            $stderr.print "Password: "
+            pwd = $stdin.noecho(&:gets)&.chomp
+            $stderr.puts
+            pwd
+          end
+
+          backend = Gemba::Achievements::RetroAchievements::Backend.new(
+            app: nil, requester: requester
+          )
+          result = nil
+          backend.on_auth_change { |status, payload| result = [status, payload] }
+          backend.login_with_password(username: username, password: password)
+
+          if result&.first == :ok
+            config.ra_username = username
+            config.ra_token    = result[1]
+            config.ra_enabled  = true
+            config.save!
+            puts "Logged in as #{username}"
+          else
+            $stderr.puts "Login failed: #{result&.[](1) || 'unknown error'}"
+            exit 1
+          end
+        end
+
+        def verify(config:, requester:)
+          username = config.ra_username
+          token    = config.ra_token
+
+          if username.empty? || token.empty?
+            $stderr.puts "Not logged in. Run: gemba ra login --username USER"
+            exit 1
+          end
+
+          backend = Gemba::Achievements::RetroAchievements::Backend.new(
+            app: nil, requester: requester
+          )
+          result = nil
+          backend.on_auth_change { |status, _| result = status }
+          backend.login_with_token(username: username, token: token)
+
+          if result == :ok
+            puts "Token valid for #{username}"
+          else
+            $stderr.puts "Token invalid or expired. Run: gemba ra login --username USER"
+            exit 1
+          end
+        end
+
+        def logout(config:)
+          config.ra_username = ""
+          config.ra_token    = ""
+          config.ra_enabled  = false
+          config.save!
+          puts "Logged out"
+        end
+
+        def achievements(options, config:, requester:)
+          username = config.ra_username
+          token    = config.ra_token
+
+          if username.empty? || token.empty?
+            $stderr.puts "Not logged in. Run: gemba ra login --username USER"
+            exit 1
+          end
+
+          unless options[:rom]
+            $stderr.puts "Error: --rom PATH is required"
+            $stderr.puts "Run 'gemba ra achievements --help' for usage"
+            exit 1
+          end
+
+          require "digest"
+
+          backend = Gemba::Achievements::RetroAchievements::Backend.new(
+            app: nil, requester: requester
+          )
+          backend.login_with_token(username: username, token: token)
+
+          rom_path = options[:rom]
+          md5      = Digest::MD5.file(rom_path).hexdigest
+          rom_info = Struct.new(:md5, :title).new(md5, File.basename(rom_path, ".*"))
+
+          list = nil
+          backend.fetch_for_display(rom_info: rom_info) { |result| list = result }
+
+          if list.nil?
+            $stderr.puts "No achievements found (game not recognized by RetroAchievements)"
+            exit 1
+          end
+
+          if options[:json]
+            require "json"
+            puts JSON.generate(list.map { |a|
+              { id: a.id, title: a.title, description: a.description,
+                points: a.points, earned: a.earned?, earned_at: a.earned_at }
+            })
+          else
+            earned = list.count(&:earned?)
+            puts "#{earned}/#{list.size} achievements — #{rom_info.title}"
+            puts
+            list.each do |a|
+              mark = a.earned? ? "X" : " "
+              puts "  [#{mark}] #{a.title} (#{a.points}pts)"
+              puts "       #{a.description}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gemba/cli/commands/version.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'gemba/version'
+
+module Gemba
+  class CLI
+    module Commands
+      class Version
+        def initialize(argv, dry_run: false)
+          @dry_run = dry_run
+        end
+
+        def call
+          result = { command: :version, version: Gemba::VERSION }
+          return result if @dry_run
+
+          puts "gemba #{Gemba::VERSION}"
+        end
+      end
+    end
+  end
+end