plai_testr 0.1.1

data/lib/plai_testr/reporter/think_log.rb

@@ -0,0 +1,32 @@
+module PlaiTestr
+  module Reporter
+    class ThinkLog
+      HEADER = /^\[(\S+)\] model=(\S+)(.*)$/
+
+      def self.load(path)
+        new(File.exist?(path) ? File.read(path) : '')
+      end
+
+      attr_reader :calls
+
+      def initialize(text)
+        @calls = text.scan(HEADER).map do |time, model, stats|
+          stats.scan(/(\w+)=([\d.]+)/).to_h { |key, value| [key, value.to_f] }.merge('time' => Time.parse(time), 'model' => model)
+        end
+      end
+
+      def values(key) = @calls.filter_map { |call| call[key] }
+
+      def average(key)
+        list = values(key)
+        list.empty? ? nil : list.sum / list.length
+      end
+
+      def minutes
+        return nil if @calls.length < 2
+
+        (@calls.last['time'] - @calls.first['time']) / 60.0
+      end
+    end
+  end
+end

data/lib/plai_testr/rules_loader.rb

@@ -0,0 +1,40 @@
+module PlaiTestr
+  class RulesLoader
+    def self.load(path)
+      (@cache ||= {})[[File.expand_path(path), File.mtime(path)]] ||= parse(path)
+    rescue Errno::ENOENT
+      raise RulesError, "Rules file not found: #{path}"
+    end
+
+    def self.parse(path)
+      rules  = JSON.parse(File.read(path))
+      errors = validate(rules)
+      raise RulesError, "Invalid rules file #{path}:\n#{errors.map { |e| "  - #{e}" }.join("\n")}" unless errors.empty?
+
+      rules
+    rescue Errno::ENOENT
+      raise RulesError, "Rules file not found: #{path}"
+    rescue JSON::ParserError => e
+      raise RulesError, "#{path} is not valid JSON: #{e.message}"
+    end
+
+    def self.validate(rules)
+      game = rules['game']
+      return ["'game' must be an object with a name and version"] unless game.is_a?(Hash)
+
+      errors = %w[name version].filter_map { |key| "game.#{key} is required" if game[key].to_s.empty? }
+      errors << player_count_error(game['player_count']) if game.key?('player_count')
+      rules.fetch('components', []).each do |component|
+        errors << "components: #{component['name']} 'values' must be an array" if component['type'] == 'card_deck' && !component.fetch('values', []).is_a?(Array)
+      end
+      errors.compact
+    end
+
+    def self.player_count_error(range)
+      min, default, max = range.is_a?(Hash) ? range.values_at('min', 'default', 'max') : []
+      return nil if [min, default, max].all?(Integer) && min <= default && default <= max
+
+      'game.player_count needs whole numbers with min <= default <= max'
+    end
+  end
+end

data/lib/plai_testr/session/frame_queue.rb

@@ -0,0 +1,47 @@
+module PlaiTestr
+  module Session
+    module FrameQueue
+      def frame_queue
+        raise NotImplementedError, "#{self.class} must implement #frame_queue"
+      end
+
+      def schedule_frames
+        raise NotImplementedError, "#{self.class} must implement #schedule_frames"
+      end
+
+      def halt_frames? = game_over?
+
+      def intercept_frame(_frame) = false
+
+      private
+
+      def frame = frame_queue.last
+
+      def frame_for(type, player = nil, **data)
+        { 'type' => type, 'player' => player }.merge(data.transform_keys(&:to_s))
+      end
+
+      def resolve_frame(params)
+        current = frame_queue.pop
+        send("on_#{current['type']}", current, params)
+        advance_frames
+      end
+
+      def advance_frames
+        loop do
+          return if halt_frames?
+
+          schedule_frames if frame_queue.empty?
+          current = frame
+
+          if current['auto']
+            frame_queue.pop
+            send("on_#{current['type']}", current)
+          elsif !intercept_frame(current)
+            return
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plai_testr/session/manager.rb

@@ -0,0 +1,77 @@
+module PlaiTestr
+  module Session
+    class Manager
+      attr_reader :session_id
+
+      def initialize(session_id: nil, base_dir: PlaiTestr.sessions_dir, persist: true)
+        # A timestamp: readable and sortable. A second session started within the same second
+        # gets a counter suffix (-2, -3, …) so ids stay unique.
+        @base_dir   = base_dir
+        @session_id = (session_id || timestamp_id).to_s
+        FileUtils.mkdir_p(session_dir) if persist
+      end
+
+      def save_checkpoint(game_state, turn_log, metadata = {})
+        data = {
+          'session_id'    => @session_id,
+          'saved_at'      => Time.now.iso8601,
+          'status'        => metadata['status'] || 'in_progress',
+          'game'          => metadata['game'],
+          'rules_version' => metadata['rules_version'],
+          'fingerprint'   => metadata['fingerprint'],
+          'game_state'    => game_state.serialize,
+          'turn_log'      => turn_log
+        }
+
+        temp = "#{checkpoint_path}.tmp"
+        File.open(temp, 'w') do |file|
+          file.write(JSON.pretty_generate(data))
+          file.fsync
+        end
+        File.rename(temp, checkpoint_path)
+      end
+
+      def load_checkpoint
+        JSON.parse(File.read(checkpoint_path))
+      rescue Errno::ENOENT
+        raise SessionError, "No saved session #{@session_id} in #{@base_dir}"
+      rescue JSON::ParserError => e
+        raise SessionError, "Session #{@session_id} cannot be resumed: #{checkpoint_path} is unreadable (#{e.message.lines.first.strip})"
+      end
+
+      def append_transcript_entry(entry)
+        File.open(transcript_path, 'a') { |f| f.puts(JSON.generate(entry)) }
+      end
+
+      def timestamp_id
+        stamp = Time.now.strftime('%Y%m%d-%H%M%S')
+        id    = stamp
+        count = 1
+        id    = "#{stamp}-#{count += 1}" while Dir.exist?(File.join(@base_dir, id))
+        id
+      end
+
+      def session_dir
+        File.join(@base_dir, @session_id)
+      end
+
+      def checkpoint_path
+        File.join(session_dir, 'state.json')
+      end
+
+      def transcript_path
+        File.join(session_dir, 'transcript.jsonl')
+      end
+
+      def self.list(base_dir: PlaiTestr.sessions_dir)
+        return [] unless Dir.exist?(base_dir)
+
+        Dir.glob(File.join(base_dir, '*', 'state.json')).filter_map do |path|
+          JSON.parse(File.read(path)).slice('session_id', 'game', 'saved_at', 'status')
+        rescue JSON::ParserError
+          nil
+        end.sort_by { |s| s['saved_at'] }.reverse
+      end
+    end
+  end
+end