binpacker 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d0c30480b18ff759a0611116ea6c21fd5e5034525aa4ebfa95ab65fb3f2fdf2
-  data.tar.gz: 9b273d060dfbef0b2812bc2617e7eeaed00bee6247c6381d51d8b075132b28e8
+  metadata.gz: dfee21fa79b8b157afbe89bba482a2a8c2b95c4ec22dbff36117a269275f47ef
+  data.tar.gz: 636266dc852e315dffb3e1b815f39b615e4a73be4cfa9dac445a01ef7b7d76fc
 SHA512:
-  metadata.gz: d765fe4fc0741dbd13445707da9f937e4571090697c6767ddfa9ec3391e0a9a9a76935fab3ba820eb410e5bcb1d69c617668e514dd4656c46134b1a15cc87097
-  data.tar.gz: 03cd6766727a30e69e259c356b53461ac54bbed7d454904535a91e9e448c4b3fe6750104e63bf7bd1ceed5eb111f47f11e88231397d58ae52304339dcdbbfca9
+  metadata.gz: 3eb4035f35100358451c5efa9ba5ae178932defb326a988d9d1e6da1521c79b201e68ba075f8bd2575f36a4d0ce33d92b40fd5117afbac21068e3eaabb93daf2
+  data.tar.gz: 788f484e43e7d9c6d77519cabe924f6080e77ebff5e4fb1125e38721c165c1bf6bbdd6e0f4a9fa1140a3b1d62da770be746cbcd4f68dce15f36d0ab556d949c9

data/exe/binpacker-worker

@@ -3,19 +3,34 @@
 
 require "json"
 require "optparse"
+require "set"
 require "tempfile"
 
+begin
+  require "minitest"
+rescue LoadError
+  # Minitest not installed — rspec-only use
+end
+
 def run_rspec(files, wid, rspec_args)
   outfile = Tempfile.new("binpacker-rspec-out")
+  progress_outfile = Tempfile.new("binpacker-rspec-progress")
   outfile.close
+  progress_outfile.close
+
   cmd = [
     "rspec",
     "--format", "json", "--out", outfile.path,
-    "--format", "progress", "--out", "/dev/stderr",
+    "--format", "progress", "--out", progress_outfile.path,
     *rspec_args,
     *files
   ]
-  success = system(*cmd)
+  system(*cmd, exception: false)
+  exit_status = $?.exitstatus || 1
+
+  if File.exist?(progress_outfile.path) && File.size(progress_outfile.path) > 0
+    $stderr.write File.read(progress_outfile.path, encoding: "UTF-8")
+  end
 
   data = (File.exist?(outfile.path) && File.size(outfile.path) > 0) ? JSON.parse(File.read(outfile.path, encoding: "UTF-8")) : {}
   examples = data["examples"] || []
@@ -25,65 +40,170 @@ def run_rspec(files, wid, rspec_args)
     { file: ex["file_path"], name: ex["full_description"] || ex["description"], time: ex["run_time"] || 0.0 }
   end
 
-  outfile.unlink
-  [$?.exitstatus || 1, results, examples.size, (summary["failure_count"] || 0) == 0 ? examples.size : examples.size - summary["failure_count"]]
+  [exit_status, results, examples.size, (summary["failure_count"] || 0) == 0 ? examples.size : examples.size - summary["failure_count"]]
+ensure
+  outfile&.unlink
+  progress_outfile&.unlink
+end
+
+def add_project_load_paths
+  %w[lib test].each do |path|
+    expanded = File.expand_path(path)
+    $LOAD_PATH.unshift(expanded) if Dir.exist?(expanded) && !$LOAD_PATH.include?(expanded)
+  end
+end
+
+def run_minitest_after_run_hooks
+  return unless Minitest.class_variable_defined?(:@@after_run)
+
+  Minitest.class_variable_get(:@@after_run).reverse_each(&:call)
+end
+
+def run_minitest(tests, wid, minitest_args)
+  unless defined?(Minitest)
+    $stderr.puts "[worker-#{wid}] minitest is not available"
+    return [1, [], 0, 0]
+  end
+
+  def Minitest.autorun; end
+  add_project_load_paths
+
+  options = Minitest.process_args(minitest_args.dup)
+  options[:io] = $stderr
+  Minitest.seed = options[:seed]
+  srand Minitest.seed
+
+  selected = []
+  tests.group_by { |test| test["file"] }.each do |file, test_entries|
+    path = File.expand_path(file)
+    requested_names = test_entries.map { |test| test["name"] }.to_set
+    klasses_before = Minitest::Runnable.runnables.dup
+    $stderr.puts "[worker-#{wid}] loading #{file}"
+    load path
+
+    (Minitest::Runnable.runnables - klasses_before).each do |klass|
+      klass.filter_runnable_methods(options).each do |method_name|
+        full_name = "#{klass}##{method_name}"
+        selected << [klass, method_name, file, full_name] if requested_names.include?(full_name)
+      end
+    end
+  rescue StandardError => e
+    $stderr.puts "[worker-#{wid}] minitest load failed for #{file}: #{e.class}: #{e.message}"
+    return [1, [], 0, 0]
+  end
+
+  return [0, [], 0, 0] if selected.empty?
+
+  timing_reporter = TimingReporter.new
+  reporter = Minitest::CompositeReporter.new
+  reporter << Minitest::SummaryReporter.new($stderr, options)
+  reporter << Minitest::ProgressReporter.new($stderr, options) unless options[:quiet]
+  reporter << timing_reporter
+
+  Minitest.reporter = reporter
+  Minitest.init_plugins(options)
+  Minitest.reporter = nil
+
+  selected_files = selected.to_h { |_klass, _method_name, file, full_name| [full_name, file] }
+
+  Minitest.parallel_executor.start if Minitest.parallel_executor.respond_to?(:start)
+  reporter.start
+  hook_error = nil
+  begin
+    selected.each do |klass, method_name, _file, _full_name|
+      klass.run(klass, method_name, reporter)
+    end
+  ensure
+    Minitest.parallel_executor.shutdown if Minitest.parallel_executor.respond_to?(:shutdown)
+    reporter.report
+    begin
+      run_minitest_after_run_hooks
+    rescue StandardError => e
+      hook_error = e
+      $stderr.puts "[worker-#{wid}] minitest after_run failed: #{e.class}: #{e.message}"
+    end
+  end
+
+  failures = timing_reporter.results.count { |result| !result.passed? }
+  results = timing_reporter.results.map do |result|
+    full_name = "#{result.klass}##{result.name}"
+    {
+      file: selected_files.fetch(full_name, result.source_location.first),
+      name: full_name,
+      time: result.time
+    }
+  end
+
+  exit_code = reporter.passed? && hook_error.nil? ? 0 : 1
+  passed = results.size - failures
+  [exit_code, results, results.size, passed]
 end
 
-def run_minitest(files, wid, _args)
-  results = []
-  exit_code = 0
-  files.each do |file|
-    start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    s = system("ruby", "-Ilib:test", file, exception: false)
-    elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
-    results << { file: file, name: file, time: elapsed }
-    exit_code = s.exitstatus unless s.success?
+if defined?(Minitest)
+  class TimingReporter < Minitest::AbstractReporter
+    attr_reader :results
+
+    def initialize
+      super()
+      @results = []
+    end
+
+    def record(result)
+      @results << result
+    end
   end
-  [exit_code, results, results.size, exit_code == 0 ? results.size : 0]
 end
 
 options = { runner: "rspec", id: 0 }
 rspec_args = []
+minitest_args = []
 OptionParser.new do |opts|
   opts.on("--runner RUNNER", "rspec or minitest") { |v| options[:runner] = v }
   opts.on("--id ID", "Worker ID") { |v| options[:id] = v.to_i }
   opts.on("--rspec-arg ARG", "Pass-through to rspec") { |v| rspec_args << v }
+  opts.on("--minitest-arg ARG", "Pass-through to minitest") { |v| minitest_args << v }
 end.parse!
 
 wid = options[:id]
+exit_code = 0
 $stderr.puts "[worker-#{wid}] #{options[:runner]} worker started"
-$stdout.puts JSON.generate({ type: "ready" })
-$stdout.flush
-
-tests = []
-$stdin.each_line do |line|
-  data = JSON.parse(line.strip)
-  break if data["type"] == "done"
-  tests << data
-rescue JSON::ParserError
-  $stderr.puts "[worker-#{wid}] skip: #{line.strip[0..60]}"
-end
 
-if tests.empty?
-  $stdout.puts JSON.generate({ type: "result", exit_code: 0, passed: true, total: 0, passed_count: 0 })
+loop do
+  $stdout.puts JSON.generate({ type: "ready" })
   $stdout.flush
-  exit 0
-end
 
-files = tests.map { |t| t["file"] }.uniq
-$stderr.puts "[worker-#{wid}] #{files.size} files, #{tests.size} test entries"
+  tests = []
+  done_or_eof = false
+  $stdin.each_line do |line|
+    data = JSON.parse(line.strip)
+    if data["type"] == "done"
+      done_or_eof = true
+      break
+    end
+    tests << data
+  rescue JSON::ParserError
+    $stderr.puts "[worker-#{wid}] skip: #{line.strip[0..60]}"
+  end
 
-exit_code, results, total, passed = case options[:runner]
-when "rspec"   then run_rspec(files, wid, rspec_args)
-when "minitest" then run_minitest(files, wid, [])
-else
-  $stderr.puts "[worker-#{wid}] unknown runner: #{options[:runner]}"
-  [1, [], 0, 0]
-end
+  break if done_or_eof && tests.empty?
+  break if tests.empty? && ($stdin.eof? || $stdin.closed?)
+
+  files = tests.map { |t| t["file"] }.uniq
+  $stderr.puts "[worker-#{wid}] batch: #{files.size} files, #{tests.size} entries"
 
-results.each do |r|
-  $stdout.puts JSON.generate({ type: "timing", file: r[:file], name: r[:name], time: r[:time] })
+  exit_code, results, total, passed = case options[:runner]
+  when "rspec"   then run_rspec(files, wid, rspec_args)
+  when "minitest" then run_minitest(tests, wid, minitest_args)
+  else
+    $stderr.puts "[worker-#{wid}] unknown runner: #{options[:runner]}"
+    [1, [], 0, 0]
+  end
+
+  results.each do |r|
+    $stdout.puts JSON.generate({ type: "timing", file: r[:file], name: r[:name], time: r[:time] })
+  end
+  $stdout.puts JSON.generate({ type: "batch_result", exit_code: exit_code, passed: exit_code == 0, total: total, passed_count: passed })
+  $stdout.flush
 end
-$stdout.puts JSON.generate({ type: "result", exit_code: exit_code, passed: exit_code == 0, total: total, passed_count: passed })
-$stdout.flush
-exit exit_code
+
+exit exit_code || 0

data/lib/binpacker/calibration.rb

@@ -41,7 +41,7 @@ module Binpacker
           "--format", "json", "--out", outfile.path
         ]
       when "minitest"
-        cmd = ["ruby", "-Ilib:test", test.file, "--name", test.name]
+        cmd = ["ruby", "-Ilib:test", test.file, "--name", "/^#{Regexp.escape(test.name)}$/"]
       else
         raise ConfigError, "unsupported runner for calibration: #{@config.test_runner}"
       end

data/lib/binpacker/cli.rb

@@ -14,6 +14,7 @@ module Binpacker
       @command = nil
       @profile = nil
       @passthrough = []
+      @quiet = false
       parse!
     end
 
@@ -23,6 +24,8 @@ module Binpacker
         cmd_calibrate
       when "run"
         cmd_run
+      when "init"
+        cmd_init
       when "--version", "-v"
         puts "binpacker #{Binpacker::VERSION}"
       when "--help", "-h", nil
@@ -51,6 +54,10 @@ module Binpacker
         opts.on("--help", "Show help") do
           @command ||= "--help"
         end
+
+        opts.on("--quiet", "Suppress worker output") do
+          @quiet = true
+        end
       end
 
       # Extract passthrough arguments after "--"
@@ -63,6 +70,41 @@ module Binpacker
       @command = remaining.shift
     end
 
+    def cmd_init
+      config_path = Pathname.pwd.join("binpacker.yml")
+      if config_path.exist?
+        puts "binpacker.yml already exists at #{config_path}"
+        exit 1
+      end
+
+      framework = detect_framework
+      pattern = framework == "minitest" ? "test/**/*_test.rb" : "spec/**/*_spec.rb"
+      runner = framework
+
+      yaml = <<~YAML
+        profiles:
+          default:
+            test_runner: #{runner}
+            workers: auto
+            timing_file: binpacker.timings
+            test_pattern: "#{pattern}"
+            scheduler:
+              algorithm: lpt
+              steal_enabled: true
+          ci:
+            extends: default
+            workers: 4
+      YAML
+
+      config_path.write(yaml)
+      puts "Created #{config_path}"
+      puts "Detected test framework: #{framework}"
+      puts ""
+      puts "Next steps:"
+      puts "  1. binpacker calibrate   (seed timing data)"
+      puts "  2. binpacker run          (run in parallel)"
+    end
+
     def cmd_calibrate
       config = Config.new(profile: @profile)
       discovery_klass = config.test_runner == "rspec" ? RSpecDiscovery : MinitestDiscovery
@@ -79,21 +121,33 @@ module Binpacker
 
     def cmd_run
       config = Config.new(profile: @profile)
-      orchestrator = Orchestrator.new(config, passthrough: @passthrough)
+      orchestrator = Orchestrator.new(config, passthrough: @passthrough, quiet: @quiet)
 
       puts "binpacker starting (#{config.worker_count} workers, profile: #{config.profile})"
       result = orchestrator.run
+      unit = test_unit_label(config)
 
       if result[:passed]
-        puts "All #{result[:total]} examples passed across #{config.worker_count} workers."
+        puts "All #{result[:total]} #{pluralize(result[:total], unit)} passed across #{config.worker_count} workers."
         exit 0
+      elsif result[:empty_filter]
+        puts "No tests matched the Minitest filter."
+        exit 1
       else
         failed = result[:total] - result[:passed_count]
-        puts "#{failed}/#{result[:total]} examples failed."
+        puts "#{failed}/#{result[:total]} #{pluralize(failed, unit)} failed."
         exit 1
       end
     end
 
+    def test_unit_label(config)
+      config.test_runner == "rspec" ? "example" : "test"
+    end
+
+    def pluralize(count, word)
+      count == 1 ? word : "#{word}s"
+    end
+
     def print_help
       puts <<~HELP
         binpacker #{Binpacker::VERSION}
@@ -101,16 +155,24 @@ module Binpacker
         Commands:
           run          Execute tests across worker processes
           calibrate    Run tests serially to generate timing data
+          init         Create binpacker.yml with auto-detected settings
 
         Options:
           --profile NAME   Select profile from binpacker.yml
           --help           Show this message
 
         Examples:
+          binpacker init
           binpacker run --profile ci
           binpacker run -- --tag ~slow
           binpacker calibrate
       HELP
     end
+
+    def detect_framework
+      return "minitest" if Dir.glob("test*/**/*_test.rb").any?
+      return "minitest" if Dir.glob("test*/**/test_*.rb").any?
+      "rspec"
+    end
   end
 end

data/lib/binpacker/config.rb

@@ -10,6 +10,7 @@ module Binpacker
     DEFAULTS = {
       "test_runner" => "rspec",
       "workers" => "auto",
+      "test_granularity" => "file",
       "timing_file" => "binpacker.timings",
       "test_pattern" => "spec/**/*_spec.rb",
       "test_exclude" => [],
@@ -77,6 +78,7 @@ module Binpacker
 
     def build_profile(name)
       profiles = @raw.fetch("profiles", {})
+      return DEFAULTS.dup if profiles.empty? && name == "default"
       entry = profiles[name]
       raise ConfigError, "profile '#{name}' not found in binpacker.yml" unless entry
       parent = entry["extends"]

data/lib/binpacker/orchestrator.rb

@@ -2,14 +2,16 @@
 
 module Binpacker
   class Orchestrator
-    def initialize(config, passthrough: [])
+    BATCH_SIZE = 10
+
+    def initialize(config, passthrough: [], quiet: false)
       @config = config
       @passthrough = passthrough
+      @quiet = quiet
     end
 
     def run
       tests = discover
-
       timing = Timing.new(@config.timing_file)
       timings = timing.load_with_fallback(tests)
 
@@ -22,19 +24,48 @@ module Binpacker
 
       runner_class = TestRunner.for(@config.test_runner)
       workers = queues.map.with_index do |queue, idx|
-        Worker.new(idx, runner_class, passthrough: @passthrough).tap(&:start)
+        Worker.new(idx, runner_class, passthrough: @passthrough, quiet: @quiet).tap(&:start)
       end
 
+      if @config.scheduler["steal_enabled"]
+        run_dynamic(workers, queues, timing, tests)
+      else
+        run_static(workers, queues, timing, tests)
+      end
+    end
+
+    private
+
+    def discover
+      case @config.test_runner
+      when "rspec"
+        RSpecDiscovery.new(@config).enumerate
+      when "minitest"
+        MinitestDiscovery.new(@config).enumerate
+      else
+        raise ConfigError, "unsupported runner: #{@config.test_runner}"
+      end
+    end
+
+    def run_static(workers, queues, timing, tests)
+      queue_totals = queues.map(&:size)
+      progress = ProgressDisplay.new(workers.size)
+
       workers.zip(queues).each do |worker, queue|
         worker.send_tests(queue.remaining)
+        progress.update(worker.id, done: 0, total: queue_totals[worker.id], file: queue.remaining.first&.file || "")
       end
+      progress.refresh
+
+      workers.each(&:signal_done)
 
       all_timings = []
       all_passed = true
       total_examples = 0
       passed_examples = 0
-
-      workers.each(&:signal_done)
+      worker_time = Array.new(workers.size, 0.0)
+      worker_examples = Array.new(workers.size, 0)
+      worker_passed = Array.new(workers.size, 0)
 
       workers.each do |worker|
         worker.collect_results
@@ -42,6 +73,11 @@ module Binpacker
         all_passed &&= worker.success?
         total_examples += worker.example_count
         passed_examples += worker.passed_count
+        worker_examples[worker.id] = worker.example_count
+        worker_passed[worker.id] = worker.passed_count
+        worker_time[worker.id] = worker.timings.sum { |t| t[:time] }
+        progress.update(worker.id, done: queue_totals[worker.id], total: queue_totals[worker.id], file: "done")
+        progress.refresh
       rescue WorkerError => e
         $stderr.puts "worker #{worker.id} error: #{e.message}"
         all_passed = false
@@ -49,26 +85,163 @@ module Binpacker
         worker.cleanup
       end
 
+      progress.finish
+
+      worker_stats = workers.map.with_index do |w, i|
+        {
+          files: queue_totals[i],
+          total_time: worker_time[i],
+          examples: worker_examples[i],
+          passed: worker_passed[i]
+        }
+      end
+      progress.summary(worker_stats)
+
+      finalize(timing, all_timings, all_passed, total_examples, passed_examples, tests)
+    end
+
+    def run_dynamic(workers, queues, timing, tests)
+      all_timings = []
+      all_passed = true
+      total_examples = 0
+      passed_examples = 0
+      active = []
+
+      queue_totals = queues.map(&:size)
+      worker_done = Array.new(workers.size, 0)
+      batch_sizes = Array.new(workers.size, 0)
+      worker_time = Array.new(workers.size, 0.0)
+      worker_examples = Array.new(workers.size, 0)
+      worker_passed = Array.new(workers.size, 0)
+
+      progress = ProgressDisplay.new(workers.size)
+
+      workers.zip(queues).each do |worker, queue|
+        batch = drain_batch(queue)
+        if batch.empty?
+          worker.signal_done
+          worker.collect_results
+          all_timings.concat(worker.timings)
+          all_passed &&= worker.success?
+          total_examples += worker.example_count
+          passed_examples += worker.passed_count
+          worker_examples[worker.id] = worker.example_count
+          worker_passed[worker.id] = worker.passed_count
+          worker.cleanup
+          worker_done[worker.id] = queue_totals[worker.id]
+          progress.update(worker.id, done: worker_done[worker.id], total: queue_totals[worker.id], file: "done")
+        else
+          worker.send_tests(batch)
+          worker.batch_done
+          active << worker
+          batch_sizes[worker.id] = batch.size
+          current_file = batch.first&.file || ""
+          progress.update(worker.id, done: 0, total: queue_totals[worker.id], file: current_file)
+        end
+      end
+
+      until active.empty?
+        ready = active.find { |w| w.wait_for_batch }
+        unless ready
+          active.reject! { |w| w.status == :crashed || w.status == :error }
+          sleep 0.1
+          next
+        end
+
+        begin
+          all_passed &&= ready.success?
+          total_examples += ready.example_count
+          passed_examples += ready.passed_count
+
+          worker_done[ready.id] += batch_sizes[ready.id]
+          worker_examples[ready.id] = ready.example_count
+          worker_passed[ready.id] = ready.passed_count
+
+          own_queue = queues[ready.id]
+          next_batch = drain_batch(own_queue)
+
+          if next_batch.empty?
+            donor = queues.reject(&:empty?).max_by(&:size)
+            next_batch = drain_batch(donor) if donor
+          end
+
+          if next_batch.any?
+            ready.send_tests(next_batch)
+            ready.batch_done
+            batch_sizes[ready.id] = next_batch.size
+            current_file = next_batch.first&.file || ""
+            progress.update(ready.id, done: worker_done[ready.id], total: queue_totals[ready.id], file: current_file)
+            progress.refresh
+          else
+            ready.signal_done
+            all_timings.concat(ready.timings)
+            active.delete(ready)
+            worker_done[ready.id] = queue_totals[ready.id]
+            progress.update(ready.id, done: queue_totals[ready.id], total: queue_totals[ready.id], file: "done")
+            progress.refresh
+          end
+        rescue WorkerError => e
+          $stderr.puts "worker #{ready.id} error: #{e.message}"
+          all_passed = false
+          active.delete(ready)
+        end
+      end
+
+      progress.finish
+
+      worker_stats = workers.map.with_index do |w, i|
+        tw = w.timings.sum { |t| t[:time] }
+        {
+          files: queue_totals[i],
+          total_time: tw > 0 ? tw : worker_time[i],
+          examples: worker_examples[i],
+          passed: worker_passed[i]
+        }
+      end
+      progress.summary(worker_stats)
+
+      workers.each(&:cleanup)
+      finalize(timing, all_timings, all_passed, total_examples, passed_examples, tests)
+    end
+
+    def drain_batch(queue)
+      return [] if queue.nil? || queue.empty?
+      batch = []
+      BATCH_SIZE.times do
+        test = queue.pop
+        break unless test
+        batch << test
+      end
+      batch
+    end
+
+    def finalize(timing, all_timings, all_passed, total_examples, passed_examples, tests)
       timing.append_all(all_timings) unless all_timings.empty?
+      empty_filter = minitest_empty_filter?(tests, total_examples)
+      all_passed = false if empty_filter
 
       {
         passed: all_passed,
         total: total_examples,
         passed_count: passed_examples,
-        timings: all_timings
+        timings: all_timings,
+        empty_filter: empty_filter
       }
     end
 
-    private
+    def minitest_empty_filter?(tests, total_examples)
+      return false unless @config.test_runner == "minitest"
+      return false unless tests.any?
+      return false unless total_examples.zero?
 
-    def discover
-      case @config.test_runner
-      when "rspec"
-        RSpecDiscovery.new(@config).enumerate
-      when "minitest"
-        MinitestDiscovery.new(@config).enumerate
-      else
-        raise ConfigError, "unsupported runner: #{@config.test_runner}"
+      minitest_include_filter?
+    end
+
+    def minitest_include_filter?
+      @passthrough.any? do |arg|
+        %w[--name --include -n -i].include?(arg) ||
+          arg.start_with?("--name=", "--include=") ||
+          (arg.start_with?("-n", "-i") && arg.length > 2)
       end
     end
   end

data/lib/binpacker/progress.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Binpacker
+  class ProgressDisplay
+    CI_INTERVAL = 15 # seconds between CI output lines
+
+    def initialize(worker_count, tty: $stdout.tty?)
+      @worker_count = worker_count
+      @tty = tty
+      @workers = Array.new(worker_count) { { done: 0, total: 0, file: "", elapsed: 0.0 } }
+      @start = Time.now
+      @last_ci_output = Time.at(Time.now.to_f - CI_INTERVAL)
+      @lines_written = 0
+      @mutex = Mutex.new
+    end
+
+    def update(worker_id, done:, total:, file:, elapsed: 0.0)
+      @mutex.synchronize do
+        w = @workers[worker_id]
+        w[:done] = done
+        w[:total] = total
+        w[:file] = file
+        w[:elapsed] = elapsed
+      end
+    end
+
+    def refresh
+      if @tty
+        redraw
+      else
+        periodic_output
+      end
+    end
+
+    def finish(worker_stats = [])
+      return unless @tty
+      redraw
+      $stdout.puts
+    end
+
+    def summary(worker_stats)
+      active = worker_stats.reject { |s| s[:files] == 0 && s[:examples] == 0 }
+      return if active.empty?
+
+      active.each_with_index do |s, i|
+        t = format_time(s[:total_time])
+        wid = worker_stats.index(s)
+        $stdout.puts "  Worker #{wid}: #{s[:files]} files, #{t} | #{s[:examples]} examples, #{s[:passed]} passed"
+      end
+      total_files = active.sum { |s| s[:files] }
+      total_time = active.sum { |s| s[:total_time] }
+      total_examples = active.sum { |s| s[:examples] }
+      times = active.map { |s| s[:total_time] }
+      mean = total_time / active.size
+      max_dev = times.map { |t| (t - mean).abs }.max
+      dev_pct = mean > 0 ? (max_dev / mean * 100).round(1) : 0
+
+      $stdout.puts "  ──"
+      $stdout.puts "  Total: #{total_files} files, #{format_time(total_time)} | #{total_examples} examples"
+      $stdout.puts "  Balance: max deviation #{format_time(max_dev)} (#{dev_pct}%)"
+    end
+
+    private
+
+    def redraw
+      @mutex.synchronize do
+        clear_lines
+        @workers.each_with_index do |w, i|
+          bar = build_bar(w[:done], w[:total])
+          status = w[:total] > 0 && w[:done] >= w[:total] ? "done" : w[:file][-50..] || ""
+          $stdout.puts format_line(i, bar, w[:done], w[:total], status, w[:elapsed])
+        end
+        @lines_written = @worker_count
+      end
+    end
+
+    def clear_lines
+      return if @lines_written == 0
+      @lines_written.times do
+        $stdout.print "\033[A\033[K"
+      end
+    end
+
+    def build_bar(done, total)
+      return "[----------]" if total == 0
+      width = 10
+      filled = (done.to_f / total * width).round
+      "[#{'█' * filled}#{'░' * (width - filled)}]"
+    end
+
+    def format_line(idx, bar, done, total, file, elapsed)
+      ts = format_time(elapsed)
+      "W#{idx} #{bar} #{done.to_s.rjust(3)}/#{total.to_s.ljust(3)} #{file.ljust(50)} #{ts}"
+    end
+
+    def periodic_output
+      now = Time.now
+      return if now - @last_ci_output < CI_INTERVAL
+      @last_ci_output = now
+
+      parts = @workers.map.with_index do |w, i|
+        if w[:total] > 0 && w[:done] >= w[:total]
+          "W#{i}: done"
+        else
+          "W#{i}: #{w[:done]}/#{w[:total]}"
+        end
+      end
+      elapsed = (now - @start).round(1)
+      $stdout.puts "[binpacker #{elapsed}s] #{parts.join(' | ')}"
+    end
+
+    def format_time(seconds)
+      return "  0.0s" if seconds < 0.001
+      m = (seconds / 60).floor
+      s = (seconds % 60).round(1)
+      m > 0 ? "#{m}m#{s.to_s.rjust(4, '0')}s" : "#{s.to_s.rjust(5)}s"
+    end
+  end
+end

data/lib/binpacker/scheduler.rb

@@ -2,7 +2,6 @@
 
 module Binpacker
   class Scheduler
-    # Returns Array<WorkerQueue> one per worker.
     def partition(tests:, worker_count:, timings:)
       raise NotImplementedError
     end
@@ -10,28 +9,94 @@ module Binpacker
     def self.for(strategy)
       case strategy.to_s
       when "lpt" then LptScheduler.new
+      when "multifit" then MultifitScheduler.new
       else
         raise SchedulerError, "unknown scheduling algorithm: #{strategy}"
       end
     end
+
+    private
+
+    def weight(test, timings)
+      timings.fetch(test.key, Timing::DEFAULT_WEIGHT)
+    end
+
+    def sorted_by_weight(tests, timings)
+      tests.sort_by { |t| -weight(t, timings) }
+    end
   end
 
   class LptScheduler < Scheduler
-    # Longest Processing Time first.
-    # Sort tests by descending weight, assign each to the least-loaded worker.
     def partition(tests:, worker_count:, timings:)
       queues = Array.new(worker_count) { |i| WorkerQueue.new(i) }
       loads = Array.new(worker_count, 0.0)
 
-      # Sort by weight descending; unknown tests get default weight
-      sorted = tests.sort_by { |t|
-        -timings.fetch(t.key, Timing::DEFAULT_WEIGHT)
-      }
-
-      sorted.each do |test|
+      sorted_by_weight(tests, timings).each do |test|
         min_idx = loads.each_with_index.min_by { |load, _| load }.last
         queues[min_idx].push(test)
-        loads[min_idx] += timings.fetch(test.key, Timing::DEFAULT_WEIGHT)
+        loads[min_idx] += weight(test, timings)
+      end
+
+      queues
+    end
+  end
+
+  class MultifitScheduler < Scheduler
+    ITERATIONS = 7
+
+    def partition(tests:, worker_count:, timings:)
+      sorted = sorted_by_weight(tests, timings)
+
+      upper = lpt_makespan(sorted, worker_count, timings)
+      lower = [max_weight(sorted, timings), total_weight(sorted, timings) / worker_count.to_f].max
+
+      best_queues = nil
+      ITERATIONS.times do
+        mid = (upper + lower) / 2.0
+        queues = first_fit_decreasing(sorted, worker_count, mid, timings)
+
+        if queues
+          best_queues = queues
+          upper = mid
+        else
+          lower = mid
+        end
+      end
+
+      best_queues || LptScheduler.new.partition(tests: tests, worker_count: worker_count, timings: timings)
+    end
+
+    private
+
+    def lpt_makespan(sorted, worker_count, timings)
+      loads = Array.new(worker_count, 0.0)
+      sorted.each do |test|
+        min_idx = loads.each_with_index.min_by { |l, _| l }.last
+        loads[min_idx] += weight(test, timings)
+      end
+      loads.max
+    end
+
+    def max_weight(sorted, timings)
+      sorted.map { |t| weight(t, timings) }.max || 0.0
+    end
+
+    def total_weight(sorted, timings)
+      sorted.sum { |t| weight(t, timings) }
+    end
+
+    def first_fit_decreasing(sorted, worker_count, capacity, timings)
+      queues = Array.new(worker_count) { |i| WorkerQueue.new(i) }
+      loads = Array.new(worker_count, 0.0)
+
+      sorted.each do |test|
+        w = weight(test, timings)
+        idx = loads.each_with_index.find { |l, _| l + w <= capacity }&.last
+
+        return nil unless idx
+
+        queues[idx].push(test)
+        loads[idx] += w
       end
 
       queues

data/lib/binpacker/test_discovery.rb

@@ -2,7 +2,6 @@
 
 module Binpacker
   Test = Struct.new(:file, :name, keyword_init: true) do
-    # Composite key used as timing lookup and identity.
     def key
       [file, name]
     end
@@ -15,7 +14,6 @@ module Binpacker
       @exclude = config.test_exclude
     end
 
-    # Returns Array<Test>. Concrete strategies subclass this.
     def enumerate
       raise NotImplementedError
     end
@@ -27,21 +25,71 @@ module Binpacker
         @exclude.any? { |ex| File.fnmatch?(ex, f) }
       }
     end
+
+    def add_project_load_paths
+      %w[lib test].each do |path|
+        expanded = File.expand_path(path)
+        $LOAD_PATH.unshift(expanded) if Dir.exist?(expanded) && !$LOAD_PATH.include?(expanded)
+      end
+    end
   end
 
   class RSpecDiscovery < TestDiscovery
     def enumerate
-      glob_files.map { |f| Test.new(file: f, name: f) }
+      if @config.respond_to?(:test_granularity) && @config.test_granularity == "example"
+        enumerate_examples
+      else
+        glob_files.map { |f| Test.new(file: f, name: f) }
+      end
+    end
+
+    private
+
+    def enumerate_examples
+      files = glob_files
+      return [] if files.empty?
+
+      examples = run_dry_run(files)
+      examples.map { |ex|
+        Test.new(
+          file: ex["file_path"],
+          name: ex["full_description"] || ex["description"]
+        )
+      }
+    end
+
+    def run_dry_run(files)
+      cmd = ["rspec", "--dry-run", "--format", "json", *files, { err: File::NULL }]
+      out = IO.popen(cmd) { |io| io.read }
+      JSON.parse(out)["examples"] || []
+    rescue JSON::ParserError
+      raise DiscoveryError, "failed to parse rspec --dry-run output"
     end
   end
 
   class MinitestDiscovery < TestDiscovery
-    # For Minitest, we can't easily enumerate test names without running them.
-    # Instead, treat each file as a single test unit, with the file path as the name.
     def enumerate
-      glob_files.map { |f|
-        Test.new(file: f, name: f)
-      }
+      require "minitest"
+      add_project_load_paths
+      def Minitest.autorun; end
+      Minitest.seed = 42
+
+      tests = []
+      glob_files.each do |file|
+        begin
+          klasses_before = Minitest::Runnable.runnables.dup
+          load File.expand_path(file)
+
+          (Minitest::Runnable.runnables - klasses_before).each do |klass|
+            klass.runnable_methods.each do |method_name|
+              tests << Test.new(file: file, name: "#{klass}##{method_name}")
+            end
+          end
+        rescue => e
+          $stderr.puts "minitest discovery: failed to load #{file}: #{e.message}"
+        end
+      end
+      tests
     end
   end
 end

data/lib/binpacker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Binpacker
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/binpacker/worker.rb

@@ -6,13 +6,14 @@ module Binpacker
   class Worker
     attr_reader :id, :status, :example_count, :passed_count
 
-    def initialize(id, runner_class, passthrough: [])
+    def initialize(id, runner_class, passthrough: [], quiet: false)
       @id = id
       @runner_class = runner_class
       @passthrough = passthrough
+      @quiet = quiet
       @status = :created
       @timings = []
-      @exit_code = nil
+      @exit_code = 0
       @example_count = 0
       @passed_count = 0
     end
@@ -27,6 +28,7 @@ module Binpacker
       @pid = Process.spawn(
         RbConfig.ruby, worker_script,
         "--runner", @runner_class.runner_name,
+        "--id", @id.to_s,
         *passthrough_args,
         in: @stdin_r, out: @stdout_w, err: @stderr_w,
         close_others: true
@@ -35,7 +37,7 @@ module Binpacker
       @stdin_r.close; @stdout_w.close; @stderr_w.close
 
       @stderr_thread = Thread.new do
-        @stderr_r.each_line { |line| $stderr.write line }
+        @stderr_r.each_line { |line| $stderr.write line unless @quiet }
       end
 
       ready_line = read_line(timeout: 30)
@@ -59,13 +61,57 @@ module Binpacker
       @stdin_w.puts JSON.generate({ file: test.file, name: test.name })
     end
 
+    def batch_done
+      @stdin_w.puts JSON.generate({ type: "done" })
+    end
+
     def signal_done
       @stdin_w.puts JSON.generate({ type: "done" })
       @stdin_w.close
     end
 
+    def wait_for_batch
+      deadline = Time.now + 300
+      while Time.now < deadline
+        begin
+          line = read_line(timeout: 1)
+          return nil unless line
+          next unless line.strip.start_with?("{")
+          data = JSON.parse(line.strip)
+
+          if data["type"] == "timing"
+            @timings << { file: data["file"], name: data["name"], time: data["time"] }
+          elsif data["type"] == "batch_result"
+            @exit_code = data["passed"] ? 0 : 1
+            @example_count += data["total"] || 0
+            @passed_count += data["passed_count"] || 0
+            return {
+              timings: [],
+              exit_code: @exit_code,
+              examples: data["total"] || 0,
+              passed: data["passed_count"] || 0
+            }
+          elsif data["type"] == "result"
+            @exit_code = data["exit_code"]
+            @passed = data["passed"]
+            @example_count = data["total"] || 0
+            @passed_count = data["passed_count"] || 0
+            return {
+              timings: [],
+              exit_code: @exit_code,
+              examples: @example_count,
+              passed: @passed_count
+            }
+          end
+        rescue JSON::ParserError
+        end
+      end
+      nil
+    end
+
     def collect_results
       @status = :running
+
       @stdout_r.each_line do |line|
         data = JSON.parse(line.strip)
         case data["type"]
@@ -76,6 +122,13 @@ module Binpacker
           @passed = data["passed"]
           @example_count = data["total"] || 0
           @passed_count = data["passed_count"] || 0
+          break
+        when "batch_result"
+          @exit_code = data["passed"] ? 0 : 1
+          @passed = data["passed"]
+          @example_count = data["total"] || 0
+          @passed_count = data["passed_count"] || 0
+          break
         when "output"
           $stdout.write data["text"] if data["text"]
         end
@@ -109,7 +162,9 @@ module Binpacker
 
     def passthrough_args
       return [] if @passthrough.empty?
-      @passthrough.flat_map { |arg| ["--rspec-arg", arg] }
+
+      worker_arg = @runner_class.runner_name == "minitest" ? "--minitest-arg" : "--rspec-arg"
+      @passthrough.flat_map { |arg| [worker_arg, arg] }
     end
 
     def kill!

data/lib/binpacker.rb

@@ -10,6 +10,7 @@ require_relative "binpacker/worker"
 require_relative "binpacker/test_runner"
 require_relative "binpacker/calibration"
 require_relative "binpacker/orchestrator"
+require_relative "binpacker/progress"
 
 module Binpacker
   Error = Class.new(StandardError)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: binpacker
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - megurine
@@ -24,6 +24,7 @@ files:
 - lib/binpacker/cli.rb
 - lib/binpacker/config.rb
 - lib/binpacker/orchestrator.rb
+- lib/binpacker/progress.rb
 - lib/binpacker/scheduler.rb
 - lib/binpacker/test_discovery.rb
 - lib/binpacker/test_runner.rb